Full source code website bán hàng thương mại điện tử gần giống shopee

467.443 lượt xem;
1 <?php
2 /**
3  * PHPMailer - PHP email creation and transport class.
4  * PHP Version 5
5  * @package PHPMailer
6  * @link https://github.com/PHPMailer/PHPMailer/ The PHPMailer GitHub project
7  * @author Marcus Bointon (Synchro/coolbru) <phpmailer@synchromedia.co.uk>
8  * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
9  * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
10  * @author Brent R. Matzelle (original founder)
11  * @copyright 2012 - 2014 Marcus Bointon
12  * @copyright 2010 - 2012 Jim Jagielski
13  * @copyright 2004 - 2009 Andy Prevost
14  * @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
15  * @note This program is distributed in the hope that it will be useful - WITHOUT
16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17  * FITNESS FOR A PARTICULAR PURPOSE.
18  */
19
20 /**
21  * PHPMailer - PHP email creation and transport class.
22  * @package PHPMailer
23  * @author Marcus Bointon (Synchro/coolbru) <phpmailer@synchromedia.co.uk>
24  * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
25  * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
26  * @author Brent R. Matzelle (original founder)
27  */
28 class PHPMailer
29 {
30     /**
31      * The PHPMailer Version number.
32      * @type string
33      */
34     public $Version = '5.2.9';
35
36     /**
37      * Email priority.
38      * Options: 1 = High, 3 = Normal, 5 = low.
39      * @type integer
40      */
41     public $Priority = 3;
42
43     /**
44      * The character set of the message.
45      * @type string
46      */
47     public $CharSet = 'iso-8859-1';
48
49     /**
50      * The MIME Content-type of the message.
51      * @type string
52      */
53     public $ContentType = 'text/plain';
54
55     /**
56      * The message encoding.
57      * Options: "8bit", "7bit", "binary", "base64", and "quoted-printable".
58      * @type string
59      */
60     public $Encoding = '8bit';
61
62     /**
63      * Holds the most recent mailer error message.
64      * @type string
65      */
66     public $ErrorInfo = '';
67
68     /**
69      * The From email address for the message.
70      * @type string
71      */
72     public $From = 'root@localhost';
73
74     /**
75      * The From name of the message.
76      * @type string
77      */
78     public $FromName = 'Root User';
79
80     /**
81      * The Sender email (Return-Path) of the message.
82      * If not empty, will be sent via -f to sendmail or as 'MAIL FROM' in smtp mode.
83      * @type string
84      */
85     public $Sender = '';
86
87     /**
88      * The Return-Path of the message.
89      * If empty, it will be set to either From or Sender.
90      * @type string
91      * @deprecated Email senders should never set a return-path header;
92      * it's the receiver's job (RFC5321 section 4.4), so this no longer does anything.
93      * @link https://tools.ietf.org/html/rfc5321#section-4.4 RFC5321 reference
94      */
95     public $ReturnPath = '';
96
97     /**
98      * The Subject of the message.
99      * @type string
100      */
101     public $Subject = '';
102
103     /**
104      * An HTML or plain text message body.
105      * If HTML then call isHTML(true).
106      * @type string
107      */
108     public $Body = '';
109
110     /**
111      * The plain-text message body.
112      * This body can be read by mail clients that do not have HTML email
113      * capability such as mutt & Eudora.
114      * Clients that can read HTML will view the normal Body.
115      * @type string
116      */
117     public $AltBody = '';
118
119     /**
120      * An iCal message part body.
121      * Only supported in simple alt or alt_inline message types
122      * To generate iCal events, use the bundled extras/EasyPeasyICS.php class or iCalcreator
123      * @link http://sprain.ch/blog/downloads/php-class-easypeasyics-create-ical-files-with-php/
124      * @link http://kigkonsult.se/iCalcreator/
125      * @type string
126      */
127     public $Ical = '';
128
129     /**
130      * The complete compiled MIME message body.
131      * @access protected
132      * @type string
133      */
134     protected $MIMEBody = '';
135
136     /**
137      * The complete compiled MIME message headers.
138      * @type string
139      * @access protected
140      */
141     protected $MIMEHeader = '';
142
143     /**
144      * Extra headers that createHeader() doesn't fold in.
145      * @type string
146      * @access protected
147      */
148     protected $mailHeader = '';
149
150     /**
151      * Word-wrap the message body to this number of chars.
152      * Set to 0 to not wrap. A useful value here is 78, for RFC2822 section 2.1.1 compliance.
153      * @type integer
154      */
155     public $WordWrap = 0;
156
157     /**
158      * Which method to use to send mail.
159      * Options: "mail", "sendmail", or "smtp".
160      * @type string
161      */
162     public $Mailer = 'mail';
163
164     /**
165      * The path to the sendmail program.
166      * @type string
167      */
168     public $Sendmail = '/usr/sbin/sendmail';
169
170     /**
171      * Whether mail() uses a fully sendmail-compatible MTA.
172      * One which supports sendmail's "-oi -f" options.
173      * @type boolean
174      */
175     public $UseSendmailOptions = true;
176
177     /**
178      * Path to PHPMailer plugins.
179      * Useful if the SMTP class is not in the PHP include path.
180      * @type string
181      * @deprecated Should not be needed now there is an autoloader.
182      */
183     public $PluginDir = '';
184
185     /**
186      * The email address that a reading confirmation should be sent to.
187      * @type string
188      */
189     public $ConfirmReadingTo = '';
190
191     /**
192      * The hostname to use in Message-Id and Received headers
193      * and as default HELO string.
194      * If empty, the value returned
195      * by SERVER_NAME is used or 'localhost.localdomain'.
196      * @type string
197      */
198     public $Hostname = '';
199
200     /**
201      * An ID to be used in the Message-Id header.
202      * If empty, a unique id will be generated.
203      * @type string
204      */
205     public $MessageID = '';
206
207     /**
208      * The message Date to be used in the Date header.
209      * If empty, the current date will be added.
210      * @type string
211      */
212     public $MessageDate = '';
213
214     /**
215      * SMTP hosts.
216      * Either a single hostname or multiple semicolon-delimited hostnames.
217      * You can also specify a different port
218      * for each host by using this format: [hostname:port]
219      * (e.g. "smtp1.example.com:25;smtp2.example.com").
220      * You can also specify encryption type, for example:
221      * (e.g. "tls://smtp1.example.com:587;ssl://smtp2.example.com:465").
222      * Hosts will be tried in order.
223      * @type string
224      */
225     public $Host = 'localhost';
226
227     /**
228      * The default SMTP server port.
229      * @type integer
230      * @TODO Why is this needed when the SMTP class takes care of it?
231      */
232     public $Port = 25;
233
234     /**
235      * The SMTP HELO of the message.
236      * Default is $Hostname.
237      * @type string
238      * @see PHPMailer::$Hostname
239      */
240     public $Helo = '';
241
242     /**
243      * The secure connection prefix.
244      * Options: "", "ssl" or "tls"
245      * @type string
246      */
247     public $SMTPSecure = '';
248
249     /**
250      * Whether to use SMTP authentication.
251      * Uses the Username and Password properties.
252      * @type boolean
253      * @see PHPMailer::$Username
254      * @see PHPMailer::$Password
255      */
256     public $SMTPAuth = false;
257
258     /**
259      * SMTP username.
260      * @type string
261      */
262     public $Username = '';
263
264     /**
265      * SMTP password.
266      * @type string
267      */
268     public $Password = '';
269
270     /**
271      * SMTP auth type.
272      * Options are LOGIN (default), PLAIN, NTLM, CRAM-MD5
273      * @type string
274      */
275     public $AuthType = '';
276
277     /**
278      * SMTP realm.
279      * Used for NTLM auth
280      * @type string
281      */
282     public $Realm = '';
283
284     /**
285      * SMTP workstation.
286      * Used for NTLM auth
287      * @type string
288      */
289     public $Workstation = '';
290
291     /**
292      * The SMTP server timeout in seconds.
293      * Default of 5 minutes (300sec) is from RFC2821 section 4.5.3.2
294      * @type integer
295      */
296     public $Timeout = 300;
297
298     /**
299      * SMTP class debug output mode.
300      * Debug output level.
301      * Options:
302      * * `0` No output
303      * * `1` Commands
304      * * `2` Data and commands
305      * * `3` As 2 plus connection status
306      * * `4` Low-level data output
307      * @type integer
308      * @see SMTP::$do_debug
309      */
310     public $SMTPDebug = 0;
311
312     /**
313      * How to handle debug output.
314      * Options:
315      * * `echo` Output plain-text as-is, appropriate for CLI
316      * * `html` Output escaped, line breaks converted to `<br>`, appropriate for browser output
317      * * `error_log` Output to error log as configured in php.ini
318      *
319      * Alternatively, you can provide a callable expecting two params: a message string and the debug level:
320      * <code>
321      * $mail->Debugoutput = function($str, $level) {echo "debug level $level; message: $str";};
322      * </code>
323      * @type string|callable
324      * @see SMTP::$Debugoutput
325      */
326     public $Debugoutput = 'echo';
327
328     /**
329      * Whether to keep SMTP connection open after each message.
330      * If this is set to true then to close the connection
331      * requires an explicit call to smtpClose().
332      * @type boolean
333      */
334     public $SMTPKeepAlive = false;
335
336     /**
337      * Whether to split multiple to addresses into multiple messages
338      * or send them all in one message.
339      * @type boolean
340      */
341     public $SingleTo = false;
342
343     /**
344      * Storage for addresses when SingleTo is enabled.
345      * @type array
346      * @TODO This should really not be public
347      */
348     public $SingleToArray = array();
349
350     /**
351      * Whether to generate VERP addresses on send.
352      * Only applicable when sending via SMTP.
353      * @link http://en.wikipedia.org/wiki/Variable_envelope_return_path
354      * @link http://www.postfix.org/VERP_README.html Postfix VERP info
355      * @type boolean
356      */
357     public $do_verp = false;
358
359     /**
360      * Whether to allow sending messages with an empty body.
361      * @type boolean
362      */
363     public $AllowEmpty = false;
364
365     /**
366      * The default line ending.
367      * @note The default remains "\n". We force CRLF where we know
368      * it must be used via self::CRLF.
369      * @type string
370      */
371     public $LE = "\n";
372
373     /**
374      * DKIM selector.
375      * @type string
376      */
377     public $DKIM_selector = '';
378
379     /**
380      * DKIM Identity.
381      * Usually the email address used as the source of the email
382      * @type string
383      */
384     public $DKIM_identity = '';
385
386     /**
387      * DKIM passphrase.
388      * Used if your key is encrypted.
389      * @type string
390      */
391     public $DKIM_passphrase = '';
392
393     /**
394      * DKIM signing domain name.
395      * @example 'example.com'
396      * @type string
397      */
398     public $DKIM_domain = '';
399
400     /**
401      * DKIM private key file path.
402      * @type string
403      */
404     public $DKIM_private = '';
405
406     /**
407      * Callback Action function name.
408      *
409      * The function that handles the result of the send email action.
410      * It is called out by send() for each email sent.
411      *
412      * Value can be any php callable: http://www.php.net/is_callable
413      *
414      * Parameters:
415      * boolean $result result of the send action
416      * string $to email address of the recipient
417      * string $cc cc email addresses
418      * string $bcc bcc email addresses
419      * string $subject the subject
420      * string $body the email body
421      * string $from email address of sender
422      * @type string
423      */
424     public $action_function = '';
425
426     /**
427      * What to put in the X-Mailer header.
428      * Options: An empty string for PHPMailer default, whitespace for none, or a string to use
429      * @type string
430      */
431     public $XMailer = '';
432
433     /**
434      * An instance of the SMTP sender class.
435      * @type SMTP
436      * @access protected
437      */
438     protected $smtp = null;
439
440     /**
441      * The array of 'to' addresses.
442      * @type array
443      * @access protected
444      */
445     protected $to = array();
446
447     /**
448      * The array of 'cc' addresses.
449      * @type array
450      * @access protected
451      */
452     protected $cc = array();
453
454     /**
455      * The array of 'bcc' addresses.
456      * @type array
457      * @access protected
458      */
459     protected $bcc = array();
460
461     /**
462      * The array of reply-to names and addresses.
463      * @type array
464      * @access protected
465      */
466     protected $ReplyTo = array();
467
468     /**
469      * An array of all kinds of addresses.
470      * Includes all of $to, $cc, $bcc, $replyto
471      * @type array
472      * @access protected
473      */
474     protected $all_recipients = array();
475
476     /**
477      * The array of attachments.
478      * @type array
479      * @access protected
480      */
481     protected $attachment = array();
482
483     /**
484      * The array of custom headers.
485      * @type array
486      * @access protected
487      */
488     protected $CustomHeader = array();
489
490     /**
491      * The most recent Message-ID (including angular brackets).
492      * @type string
493      * @access protected
494      */
495     protected $lastMessageID = '';
496
497     /**
498      * The message's MIME type.
499      * @type string
500      * @access protected
501      */
502     protected $message_type = '';
503
504     /**
505      * The array of MIME boundary strings.
506      * @type array
507      * @access protected
508      */
509     protected $boundary = array();
510
511     /**
512      * The array of available languages.
513      * @type array
514      * @access protected
515      */
516     protected $language = array();
517
518     /**
519      * The number of errors encountered.
520      * @type integer
521      * @access protected
522      */
523     protected $error_count = 0;
524
525     /**
526      * The S/MIME certificate file path.
527      * @type string
528      * @access protected
529      */
530     protected $sign_cert_file = '';
531
532     /**
533      * The S/MIME key file path.
534      * @type string
535      * @access protected
536      */
537     protected $sign_key_file = '';
538
539     /**
540      * The S/MIME password for the key.
541      * Used only if the key is encrypted.
542      * @type string
543      * @access protected
544      */
545     protected $sign_key_pass = '';
546
547     /**
548      * Whether to throw exceptions for errors.
549      * @type boolean
550      * @access protected
551      */
552     protected $exceptions = false;
553
554     /**
555      * Error severity: message only, continue processing.
556      */
557     const STOP_MESSAGE = 0;
558
559     /**
560      * Error severity: message, likely ok to continue processing.
561      */
562     const STOP_CONTINUE = 1;
563
564     /**
565      * Error severity: message, plus full stop, critical error reached.
566      */
567     const STOP_CRITICAL = 2;
568
569     /**
570      * SMTP RFC standard line ending.
571      */
572     const CRLF = "\r\n";
573
574     /**
575      * Constructor.
576      * @param boolean $exceptions Should we throw external exceptions?
577      */
578     public function __construct($exceptions = false)
579     {
580         $this->exceptions = (boolean)$exceptions;
581     }
582
583     /**
584      * Destructor.
585      */
586     public function __destruct()
587     {
588         if ($this->Mailer == 'smtp') { //close any open SMTP connection nicely
589             $this->smtpClose();
590         }
591     }
592
593     /**
594      * Call mail() in a safe_mode-aware fashion.
595      * Also, unless sendmail_path points to sendmail (or something that
596      * claims to be sendmail), don't pass params (not a perfect fix,
597      * but it will do)
598      * @param string $to To
599      * @param string $subject Subject
600      * @param string $body Message Body
601      * @param string $header Additional Header(s)
602      * @param string $params Params
603      * @access private
604      * @return boolean
605      */
606     private function mailPassthru($to, $subject, $body, $header, $params)
607     {
608         //Check overloading of mail function to avoid double-encoding
609         if (ini_get('mbstring.func_overload') & 1) {
610             $subject = $this->secureHeader($subject);
611         } else {
612             $subject = $this->encodeHeader($this->secureHeader($subject));
613         }
614         if (ini_get('safe_mode') || !($this->UseSendmailOptions)) {
615             $result = @mail($to, $subject, $body, $header);
616         } else {
617             $result = @mail($to, $subject, $body, $header, $params);
618         }
619         return $result;
620     }
621
622     /**
623      * Output debugging info via user-defined method.
624      * Only generates output if SMTP debug output is enabled (@see SMTP::$do_debug).
625      * @see PHPMailer::$Debugoutput
626      * @see PHPMailer::$SMTPDebug
627      * @param string $str
628      */
629     protected function edebug($str)
630     {
631         if ($this->SMTPDebug <= 0) {
632             return;
633         }
634         //Avoid clash with built-in function names
635         if (!in_array($this->Debugoutput, array('error_log', 'html', 'echo')) and is_callable($this->Debugoutput)) {
636             call_user_func($this->Debugoutput, $str, $this->SMTPDebug);
637             return;
638         }
639         switch ($this->Debugoutput) {
640             case 'error_log':
641                 //Don't output, just log
642                 error_log($str);
643                 break;
644             case 'html':
645                 //Cleans up output a bit for a better looking, HTML-safe output
646                 echo htmlentities(
647                     preg_replace('/[\r\n]+/', '', $str),
648                     ENT_QUOTES,
649                     'UTF-8'
650                 )
651                 . "<br>\n";
652                 break;
653             case 'echo':
654             default:
655                 //Normalize line breaks
656                 $str = preg_replace('/(\r\n|\r|\n)/ms', "\n", $str);
657                 echo gmdate('Y-m-d H:i:s') . "\t" . str_replace(
658                     "\n",
659                     "\n \t ",
660                     trim($str)
661                 ) . "\n";
662         }
663     }
664
665     /**
666      * Sets message type to HTML or plain.
667      * @param boolean $isHtml True for HTML mode.
668      * @return void
669      */
670     public function isHTML($isHtml = true)
671     {
672         if ($isHtml) {
673             $this->ContentType = 'text/html';
674         } else {
675             $this->ContentType = 'text/plain';
676         }
677     }
678
679     /**
680      * Send messages using SMTP.
681      * @return void
682      */
683     public function isSMTP()
684     {
685         $this->Mailer = 'smtp';
686     }
687
688     /**
689      * Send messages using PHP's mail() function.
690      * @return void
691      */
692     public function isMail()
693     {
694         $this->Mailer = 'mail';
695     }
696
697     /**
698      * Send messages using $Sendmail.
699      * @return void
700      */
701     public function isSendmail()
702     {
703         $ini_sendmail_path = ini_get('sendmail_path');
704
705         if (!stristr($ini_sendmail_path, 'sendmail')) {
706             $this->Sendmail = '/usr/sbin/sendmail';
707         } else {
708             $this->Sendmail = $ini_sendmail_path;
709         }
710         $this->Mailer = 'sendmail';
711     }
712
713     /**
714      * Send messages using qmail.
715      * @return void
716      */
717     public function isQmail()
718     {
719         $ini_sendmail_path = ini_get('sendmail_path');
720
721         if (!stristr($ini_sendmail_path, 'qmail')) {
722             $this->Sendmail = '/var/qmail/bin/qmail-inject';
723         } else {
724             $this->Sendmail = $ini_sendmail_path;
725         }
726         $this->Mailer = 'qmail';
727     }
728
729     /**
730      * Add a "To" address.
731      * @param string $address
732      * @param string $name
733      * @return boolean true on success, false if address already used
734      */
735     public function addAddress($address, $name = '')
736     {
737         return $this->addAnAddress('to', $address, $name);
738     }
739
740     /**
741      * Add a "CC" address.
742      * @note: This function works with the SMTP mailer on win32, not with the "mail" mailer.
743      * @param string $address
744      * @param string $name
745      * @return boolean true on success, false if address already used
746      */
747     public function addCC($address, $name = '')
748     {
749         return $this->addAnAddress('cc', $address, $name);
750     }
751
752     /**
753      * Add a "BCC" address.
754      * @note: This function works with the SMTP mailer on win32, not with the "mail" mailer.
755      * @param string $address
756      * @param string $name
757      * @return boolean true on success, false if address already used
758      */
759     public function addBCC($address, $name = '')
760     {
761         return $this->addAnAddress('bcc', $address, $name);
762     }
763
764     /**
765      * Add a "Reply-to" address.
766      * @param string $address
767      * @param string $name
768      * @return boolean
769      */
770     public function addReplyTo($address, $name = '')
771     {
772         return $this->addAnAddress('Reply-To', $address, $name);
773     }
774
775     /**
776      * Add an address to one of the recipient arrays.
777      * Addresses that have been added already return false, but do not throw exceptions
778      * @param string $kind One of 'to', 'cc', 'bcc', 'ReplyTo'
779      * @param string $address The email address to send to
780      * @param string $name
781      * @throws phpmailerException
782      * @return boolean true on success, false if address already used or invalid in some way
783      * @access protected
784      */
785     protected function addAnAddress($kind, $address, $name = '')
786     {
787         if (!preg_match('/^(to|cc|bcc|Reply-To)$/', $kind)) {
788             $this->setError($this->lang('Invalid recipient array') . ': ' . $kind);
789             $this->edebug($this->lang('Invalid recipient array') . ': ' . $kind);
790             if ($this->exceptions) {
791                 throw new phpmailerException('Invalid recipient array: ' . $kind);
792             }
793             return false;
794         }
795         $address = trim($address);
796         $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
797         if (!$this->validateAddress($address)) {
798             $this->setError($this->lang('invalid_address') . ': ' . $address);
799             $this->edebug($this->lang('invalid_address') . ': ' . $address);
800             if ($this->exceptions) {
801                 throw new phpmailerException($this->lang('invalid_address') . ': ' . $address);
802             }
803             return false;
804         }
805         if ($kind != 'Reply-To') {
806             if (!isset($this->all_recipients[strtolower($address)])) {
807                 array_push($this->$kind, array($address, $name));
808                 $this->all_recipients[strtolower($address)] = true;
809                 return true;
810             }
811         } else {
812             if (!array_key_exists(strtolower($address), $this->ReplyTo)) {
813                 $this->ReplyTo[strtolower($address)] = array($address, $name);
814                 return true;
815             }
816         }
817         return false;
818     }
819
820     /**
821      * Set the From and FromName properties.
822      * @param string $address
823      * @param string $name
824      * @param boolean $auto Whether to also set the Sender address, defaults to true
825      * @throws phpmailerException
826      * @return boolean
827      */
828     public function setFrom($address, $name = '', $auto = true)
829     {
830         $address = trim($address);
831         $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
832         if (!$this->validateAddress($address)) {
833             $this->setError($this->lang('invalid_address') . ': ' . $address);
834             $this->edebug($this->lang('invalid_address') . ': ' . $address);
835             if ($this->exceptions) {
836                 throw new phpmailerException($this->lang('invalid_address') . ': ' . $address);
837             }
838             return false;
839         }
840         $this->From = $address;
841         $this->FromName = $name;
842         if ($auto) {
843             if (empty($this->Sender)) {
844                 $this->Sender = $address;
845             }
846         }
847         return true;
848     }
849
850     /**
851      * Return the Message-ID header of the last email.
852      * Technically this is the value from the last time the headers were created,
853      * but it's also the message ID of the last sent message except in
854      * pathological cases.
855      * @return string
856      */
857     public function getLastMessageID()
858     {
859         return $this->lastMessageID;
860     }
861
862     /**
863      * Check that a string looks like an email address.
864      * @param string $address The email address to check
865      * @param string $patternselect A selector for the validation pattern to use :
866      * * `auto` Pick strictest one automatically;
867      * * `pcre8` Use the squiloople.com pattern, requires PCRE > 8.0, PHP >= 5.3.2, 5.2.14;
868      * * `pcre` Use old PCRE implementation;
869      * * `php` Use PHP built-in FILTER_VALIDATE_EMAIL; same as pcre8 but does not allow 'dotless' domains;
870      * * `html5` Use the pattern given by the HTML5 spec for 'email' type form input elements.
871      * * `noregex` Don't use a regex: super fast, really dumb.
872      * @return boolean
873      * @static
874      * @access public
875      */
876     public static function validateAddress($address, $patternselect = 'auto')
877     {
878         if (!$patternselect or $patternselect == 'auto') {
879             //Check this constant first so it works when extension_loaded() is disabled by safe mode
880             //Constant was added in PHP 5.2.4
881             if (defined('PCRE_VERSION')) {
882                 //This pattern can get stuck in a recursive loop in PCRE <= 8.0.2
883                 if (version_compare(PCRE_VERSION, '8.0.3') >= 0) {
884                     $patternselect = 'pcre8';
885                 } else {
886                     $patternselect = 'pcre';
887                 }
888             } elseif (function_exists('extension_loaded') and extension_loaded('pcre')) {
889                 //Fall back to older PCRE
890                 $patternselect = 'pcre';
891             } else {
892                 //Filter_var appeared in PHP 5.2.0 and does not require the PCRE extension
893                 if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
894                     $patternselect = 'php';
895                 } else {
896                     $patternselect = 'noregex';
897                 }
898             }
899         }
900         switch ($patternselect) {
901             case 'pcre8':
902                 /**
903                  * Uses the same RFC5322 regex on which FILTER_VALIDATE_EMAIL is based, but allows dotless domains.
904                  * @link http://squiloople.com/2009/12/20/email-address-validation/
905                  * @copyright 2009-2010 Michael Rushton
906                  * Feel free to use and redistribute this code. But please keep this copyright notice.
907                  */
908                 return (boolean)preg_match(
909                     '/^(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){65,}@)' .
910                     '((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)' .
911                     '(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[\]-\x7F]|\\\[\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)' .
912                     '([!#-\'*+\/-9=?^-~-]+|"(?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\x7F]))*' .
913                     '(?2)")(?>(?1)\.(?1)(?4))*(?1)@(?!(?1)[a-z0-9-]{64,})(?1)(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)' .
914                     '(?>(?1)\.(?!(?1)[a-z0-9-]{64,})(?1)(?5)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?6)){7}' .
915                     '|(?!(?:.*[a-f0-9][:\]]){8,})((?6)(?>:(?6)){0,6})?::(?7)?))|(?>(?>IPv6:(?>(?6)(?>:(?6)){5}:' .
916                     '|(?!(?:.*[a-f0-9]:){6,})(?8)?::(?>((?6)(?>:(?6)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}' .
917                     '|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD',
918                     $address
919                 );
920             case 'pcre':
921                 //An older regex that doesn't need a recent PCRE
922                 return (boolean)preg_match(
923                     '/^(?!(?>"?(?>\\\[ -~]|[^"])"?){255,})(?!(?>"?(?>\\\[ -~]|[^"])"?){65,}@)(?>' .
924                     '[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*")' .
925                     '(?>\.(?>[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*"))*' .
926                     '@(?>(?![a-z0-9-]{64,})(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?)(?>\.(?![a-z0-9-]{64,})' .
927                     '(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?)){0,126}|\[(?:(?>IPv6:(?>(?>[a-f0-9]{1,4})(?>:' .
928                     '[a-f0-9]{1,4}){7}|(?!(?:.*[a-f0-9][:\]]){8,})(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,6})?' .
929                     '::(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,6})?))|(?>(?>IPv6:(?>[a-f0-9]{1,4}(?>:' .
930                     '[a-f0-9]{1,4}){5}:|(?!(?:.*[a-f0-9]:){6,})(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,4})?' .
931                     '::(?>(?:[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,4}):)?))?(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}' .
932                     '|[1-9]?[0-9])(?>\.(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}))\])$/isD',
933                     $address
934                 );
935             case 'html5':
936                 /**
937                  * This is the pattern used in the HTML5 spec for validation of 'email' type form input elements.
938                  * @link http://www.whatwg.org/specs/web-apps/current-work/#e-mail-state-(type=email)
939                  */
940                 return (boolean)preg_match(
941                     '/^[a-zA-Z0-9.!#$%&\'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}' .
942                     '[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/sD',
943                     $address
944                 );
945             case 'noregex':
946                 //No PCRE! Do something _very_ approximate!
947                 //Check the address is 3 chars or longer and contains an @ that's not the first or last char
948                 return (strlen($address) >= 3
949                     and strpos($address, '@') >= 1
950                     and strpos($address, '@') != strlen($address) - 1);
951             case 'php':
952             default:
953                 return (boolean)filter_var($address, FILTER_VALIDATE_EMAIL);
954         }
955     }
956
957     /**
958      * Create a message and send it.
959      * Uses the sending method specified by $Mailer.
960      * @throws phpmailerException
961      * @return boolean false on error - See the ErrorInfo property for details of the error.
962      */
963     public function send()
964     {
965         try {
966             if (!$this->preSend()) {
967                 return false;
968             }
969             return $this->postSend();
970         } catch (phpmailerException $exc) {
971             $this->mailHeader = '';
972             $this->setError($exc->getMessage());
973             if ($this->exceptions) {
974                 throw $exc;
975             }
976             return false;
977         }
978     }
979
980     /**
981      * Prepare a message for sending.
982      * @throws phpmailerException
983      * @return boolean
984      */
985     public function preSend()
986     {
987         try {
988             $this->mailHeader = '';
989             if ((count($this->to) + count($this->cc) + count($this->bcc)) < 1) {
990                 throw new phpmailerException($this->lang('provide_address'), self::STOP_CRITICAL);
991             }
992
993             // Set whether the message is multipart/alternative
994             if (!empty($this->AltBody)) {
995                 $this->ContentType = 'multipart/alternative';
996             }
997
998             $this->error_count = 0; // reset errors
999             $this->setMessageType();
1000             // Refuse to send an empty message unless we are specifically allowing it
1001             if (!$this->AllowEmpty and empty($this->Body)) {
1002                 throw new phpmailerException($this->lang('empty_message'), self::STOP_CRITICAL);
1003             }
1004
1005             $this->MIMEHeader = $this->createHeader();
1006             $this->MIMEBody = $this->createBody();
1007
1008             // To capture the complete message when using mail(), create
1009             // an extra header list which createHeader() doesn't fold in
1010             if ($this->Mailer == 'mail') {
1011                 if (count($this->to) > 0) {
1012                     $this->mailHeader .= $this->addrAppend('To', $this->to);
1013                 } else {
1014                     $this->mailHeader .= $this->headerLine('To', 'undisclosed-recipients:;');
1015                 }
1016                 $this->mailHeader .= $this->headerLine(
1017                     'Subject',
1018                     $this->encodeHeader($this->secureHeader(trim($this->Subject)))
1019                 );
1020             }
1021
1022             // Sign with DKIM if enabled
1023             if (!empty($this->DKIM_domain)
1024                 && !empty($this->DKIM_private)
1025                 && !empty($this->DKIM_selector)
1026                 && file_exists($this->DKIM_private)) {
1027                 $header_dkim = $this->DKIM_Add(
1028                     $this->MIMEHeader . $this->mailHeader,
1029                     $this->encodeHeader($this->secureHeader($this->Subject)),
1030                     $this->MIMEBody
1031                 );
1032                 $this->MIMEHeader = rtrim($this->MIMEHeader, "\r\n ") . self::CRLF .
1033                     str_replace("\r\n", "\n", $header_dkim) . self::CRLF;
1034             }
1035             return true;
1036
1037         } catch (phpmailerException $exc) {
1038             $this->setError($exc->getMessage());
1039             if ($this->exceptions) {
1040                 throw $exc;
1041             }
1042             return false;
1043         }
1044     }
1045
1046     /**
1047      * Actually send a message.
1048      * Send the email via the selected mechanism
1049      * @throws phpmailerException
1050      * @return boolean
1051      */
1052     public function postSend()
1053     {
1054         try {
1055             // Choose the mailer and send through it
1056             switch ($this->Mailer) {
1057                 case 'sendmail':
1058                 case 'qmail':
1059                     return $this->sendmailSend($this->MIMEHeader, $this->MIMEBody);
1060                 case 'smtp':
1061                     return $this->smtpSend($this->MIMEHeader, $this->MIMEBody);
1062                 case 'mail':
1063                     return $this->mailSend($this->MIMEHeader, $this->MIMEBody);
1064                 default:
1065                     $sendMethod = $this->Mailer.'Send';
1066                     if (method_exists($this, $sendMethod)) {
1067                         return $this->$sendMethod($this->MIMEHeader, $this->MIMEBody);
1068                     }
1069
1070                     return $this->mailSend($this->MIMEHeader, $this->MIMEBody);
1071             }
1072         } catch (phpmailerException $exc) {
1073             $this->setError($exc->getMessage());
1074             $this->edebug($exc->getMessage());
1075             if ($this->exceptions) {
1076                 throw $exc;
1077             }
1078         }
1079         return false;
1080     }
1081
1082     /**
1083      * Send mail using the $Sendmail program.
1084      * @param string $header The message headers
1085      * @param string $body The message body
1086      * @see PHPMailer::$Sendmail
1087      * @throws phpmailerException
1088      * @access protected
1089      * @return boolean
1090      */
1091     protected function sendmailSend($header, $body)
1092     {
1093         if ($this->Sender != '') {
1094             if ($this->Mailer == 'qmail') {
1095                 $sendmail = sprintf('%s -f%s', escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
1096             } else {
1097                 $sendmail = sprintf('%s -oi -f%s -t', escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
1098             }
1099         } else {
1100             if ($this->Mailer == 'qmail') {
1101                 $sendmail = sprintf('%s', escapeshellcmd($this->Sendmail));
1102             } else {
1103                 $sendmail = sprintf('%s -oi -t', escapeshellcmd($this->Sendmail));
1104             }
1105         }
1106         if ($this->SingleTo) {
1107             foreach ($this->SingleToArray as $toAddr) {
1108                 if (!@$mail = popen($sendmail, 'w')) {
1109                     throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1110                 }
1111                 fputs($mail, 'To: ' . $toAddr . "\n");
1112                 fputs($mail, $header);
1113                 fputs($mail, $body);
1114                 $result = pclose($mail);
1115                 $this->doCallback(
1116                     ($result == 0),
1117                     array($toAddr),
1118                     $this->cc,
1119                     $this->bcc,
1120                     $this->Subject,
1121                     $body,
1122                     $this->From
1123                 );
1124                 if ($result != 0) {
1125                     throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1126                 }
1127             }
1128         } else {
1129             if (!@$mail = popen($sendmail, 'w')) {
1130                 throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1131             }
1132             fputs($mail, $header);
1133             fputs($mail, $body);
1134             $result = pclose($mail);
1135             $this->doCallback(($result == 0), $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
1136             if ($result != 0) {
1137                 throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1138             }
1139         }
1140         return true;
1141     }
1142
1143     /**
1144      * Send mail using the PHP mail() function.
1145      * @param string $header The message headers
1146      * @param string $body The message body
1147      * @link http://www.php.net/manual/en/book.mail.php
1148      * @throws phpmailerException
1149      * @access protected
1150      * @return boolean
1151      */
1152     protected function mailSend($header, $body)
1153     {
1154         $toArr = array();
1155         foreach ($this->to as $toaddr) {
1156             $toArr[] = $this->addrFormat($toaddr);
1157         }
1158         $to = implode(', ', $toArr);
1159
1160         if (empty($this->Sender)) {
1161             $params = ' ';
1162         } else {
1163             $params = sprintf('-f%s', $this->Sender);
1164         }
1165         if ($this->Sender != '' and !ini_get('safe_mode')) {
1166             $old_from = ini_get('sendmail_from');
1167             ini_set('sendmail_from', $this->Sender);
1168         }
1169         $result = false;
1170         if ($this->SingleTo && count($toArr) > 1) {
1171             foreach ($toArr as $toAddr) {
1172                 $result = $this->mailPassthru($toAddr, $this->Subject, $body, $header, $params);
1173                 $this->doCallback($result, array($toAddr), $this->cc, $this->bcc, $this->Subject, $body, $this->From);
1174             }
1175         } else {
1176             $result = $this->mailPassthru($to, $this->Subject, $body, $header, $params);
1177             $this->doCallback($result, $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
1178         }
1179         if (isset($old_from)) {
1180             ini_set('sendmail_from', $old_from);
1181         }
1182         if (!$result) {
1183             throw new phpmailerException($this->lang('instantiate'), self::STOP_CRITICAL);
1184         }
1185         return true;
1186     }
1187
1188     /**
1189      * Get an instance to use for SMTP operations.
1190      * Override this function to load your own SMTP implementation
1191      * @return SMTP
1192      */
1193     public function getSMTPInstance()
1194     {
1195         if (!is_object($this->smtp)) {
1196             $this->smtp = new SMTP;
1197         }
1198         return $this->smtp;
1199     }
1200
1201     /**
1202      * Send mail via SMTP.
1203      * Returns false if there is a bad MAIL FROM, RCPT, or DATA input.
1204      * Uses the PHPMailerSMTP class by default.
1205      * @see PHPMailer::getSMTPInstance() to use a different class.
1206      * @param string $header The message headers
1207      * @param string $body The message body
1208      * @throws phpmailerException
1209      * @uses SMTP
1210      * @access protected
1211      * @return boolean
1212      */
1213     protected function smtpSend($header, $body)
1214     {
1215         $bad_rcpt = array();
1216
1217         if (!$this->smtpConnect()) {
1218             throw new phpmailerException($this->lang('smtp_connect_failed'), self::STOP_CRITICAL);
1219         }
1220         $smtp_from = ($this->Sender == '') ? $this->From : $this->Sender;
1221         if (!$this->smtp->mail($smtp_from)) {
1222             $this->setError($this->lang('from_failed') . $smtp_from . ' : ' . implode(',', $this->smtp->getError()));
1223             throw new phpmailerException($this->ErrorInfo, self::STOP_CRITICAL);
1224         }
1225
1226         // Attempt to send to all recipients
1227         foreach ($this->to as $to) {
1228             if (!$this->smtp->recipient($to[0])) {
1229                 $bad_rcpt[] = $to[0];
1230                 $isSent = false;
1231             } else {
1232                 $isSent = true;
1233             }
1234             $this->doCallback($isSent, array($to[0]), array(), array(), $this->Subject, $body, $this->From);
1235         }
1236         foreach ($this->cc as $cc) {
1237             if (!$this->smtp->recipient($cc[0])) {
1238                 $bad_rcpt[] = $cc[0];
1239                 $isSent = false;
1240             } else {
1241                 $isSent = true;
1242             }
1243             $this->doCallback($isSent, array(), array($cc[0]), array(), $this->Subject, $body, $this->From);
1244         }
1245         foreach ($this->bcc as $bcc) {
1246             if (!$this->smtp->recipient($bcc[0])) {
1247                 $bad_rcpt[] = $bcc[0];
1248                 $isSent = false;
1249             } else {
1250                 $isSent = true;
1251             }
1252             $this->doCallback($isSent, array(), array(), array($bcc[0]), $this->Subject, $body, $this->From);
1253         }
1254
1255         // Only send the DATA command if we have viable recipients
1256         if ((count($this->all_recipients) > count($bad_rcpt)) and !$this->smtp->data($header . $body)) {
1257             throw new phpmailerException($this->lang('data_not_accepted'), self::STOP_CRITICAL);
1258         }
1259         if ($this->SMTPKeepAlive) {
1260             $this->smtp->reset();
1261         } else {
1262             $this->smtp->quit();
1263             $this->smtp->close();
1264         }
1265         if (count($bad_rcpt) > 0) { // Create error message for any bad addresses
1266             throw new phpmailerException(
1267                 $this->lang('recipients_failed') . implode(', ', $bad_rcpt),
1268                 self::STOP_CONTINUE
1269             );
1270         }
1271         return true;
1272     }
1273
1274     /**
1275      * Initiate a connection to an SMTP server.
1276      * Returns false if the operation failed.
1277      * @param array $options An array of options compatible with stream_context_create()
1278      * @uses SMTP
1279      * @access public
1280      * @throws phpmailerException
1281      * @return boolean
1282      */
1283     public function smtpConnect($options = array())
1284     {
1285         if (is_null($this->smtp)) {
1286             $this->smtp = $this->getSMTPInstance();
1287         }
1288
1289         // Already connected?
1290         if ($this->smtp->connected()) {
1291             return true;
1292         }
1293
1294         $this->smtp->setTimeout($this->Timeout);
1295         $this->smtp->setDebugLevel($this->SMTPDebug);
1296         $this->smtp->setDebugOutput($this->Debugoutput);
1297         $this->smtp->setVerp($this->do_verp);
1298         $hosts = explode(';', $this->Host);
1299         $lastexception = null;
1300
1301         foreach ($hosts as $hostentry) {
1302             $hostinfo = array();
1303             if (!preg_match('/^((ssl|tls):\/\/)*([a-zA-Z0-9\.-]*):?([0-9]*)$/', trim($hostentry), $hostinfo)) {
1304                 // Not a valid host entry
1305                 continue;
1306             }
1307             // $hostinfo[2]: optional ssl or tls prefix
1308             // $hostinfo[3]: the hostname
1309             // $hostinfo[4]: optional port number
1310             // The host string prefix can temporarily override the current setting for SMTPSecure
1311             // If it's not specified, the default value is used
1312             $prefix = '';
1313             $tls = ($this->SMTPSecure == 'tls');
1314             if ($hostinfo[2] == 'ssl' or ($hostinfo[2] == '' and $this->SMTPSecure == 'ssl')) {
1315                 $prefix = 'ssl://';
1316                 $tls = false; // Can't have SSL and TLS at once
1317             } elseif ($hostinfo[2] == 'tls') {
1318                 $tls = true;
1319                 // tls doesn't use a prefix
1320             }
1321             $host = $hostinfo[3];
1322             $port = $this->Port;
1323             $tport = (integer)$hostinfo[4];
1324             if ($tport > 0 and $tport < 65536) {
1325                 $port = $tport;
1326             }
1327             if ($this->smtp->connect($prefix . $host, $port, $this->Timeout, $options)) {
1328                 try {
1329                     if ($this->Helo) {
1330                         $hello = $this->Helo;
1331                     } else {
1332                         $hello = $this->serverHostname();
1333                     }
1334                     $this->smtp->hello($hello);
1335
1336                     if ($tls) {
1337                         if (!$this->smtp->startTLS()) {
1338                             throw new phpmailerException($this->lang('connect_host'));
1339                         }
1340                         // We must resend HELO after tls negotiation
1341                         $this->smtp->hello($hello);
1342                     }
1343                     if ($this->SMTPAuth) {
1344                         if (!$this->smtp->authenticate(
1345                             $this->Username,
1346                             $this->Password,
1347                             $this->AuthType,
1348                             $this->Realm,
1349                             $this->Workstation
1350                         )
1351                         ) {
1352                             throw new phpmailerException($this->lang('authenticate'));
1353                         }
1354                     }
1355                     return true;
1356                 } catch (phpmailerException $exc) {
1357                     $lastexception = $exc;
1358                     // We must have connected, but then failed TLS or Auth, so close connection nicely
1359                     $this->smtp->quit();
1360                 }
1361             }
1362         }
1363         // If we get here, all connection attempts have failed, so close connection hard
1364         $this->smtp->close();
1365         // As we've caught all exceptions, just report whatever the last one was
1366         if ($this->exceptions and !is_null($lastexception)) {
1367             throw $lastexception;
1368         }
1369         return false;
1370     }
1371
1372     /**
1373      * Close the active SMTP session if one exists.
1374      * @return void
1375      */
1376     public function smtpClose()
1377     {
1378         if ($this->smtp !== null) {
1379             if ($this->smtp->connected()) {
1380                 $this->smtp->quit();
1381                 $this->smtp->close();
1382             }
1383         }
1384     }
1385
1386     /**
1387      * Set the language for error messages.
1388      * Returns false if it cannot load the language file.
1389      * The default language is English.
1390      * @param string $langcode ISO 639-1 2-character language code (e.g. French is "fr")
1391      * @param string $lang_path Path to the language file directory, with trailing separator (slash)
1392      * @return boolean
1393      * @access public
1394      */
1395     public function setLanguage($langcode = 'en', $lang_path = '')
1396     {
1397         // Define full set of translatable strings in English
1398         $PHPMAILER_LANG = array(
1399             'authenticate' => 'SMTP Error: Could not authenticate.',
1400             'connect_host' => 'SMTP Error: Could not connect to SMTP host.',
1401             'data_not_accepted' => 'SMTP Error: data not accepted.',
1402             'empty_message' => 'Message body empty',
1403             'encoding' => 'Unknown encoding: ',
1404             'execute' => 'Could not execute: ',
1405             'file_access' => 'Could not access file: ',
1406             'file_open' => 'File Error: Could not open file: ',
1407             'from_failed' => 'The following From address failed: ',
1408             'instantiate' => 'Could not instantiate mail function.',
1409             'invalid_address' => 'Invalid address',
1410             'mailer_not_supported' => ' mailer is not supported.',
1411             'provide_address' => 'You must provide at least one recipient email address.',
1412             'recipients_failed' => 'SMTP Error: The following recipients failed: ',
1413             'signing' => 'Signing Error: ',
1414             'smtp_connect_failed' => 'SMTP connect() failed.',
1415             'smtp_error' => 'SMTP server error: ',
1416             'variable_set' => 'Cannot set or reset variable: '
1417         );
1418         if (empty($lang_path)) {
1419             // Calculate an absolute path so it can work if CWD is not here
1420             $lang_path = dirname(__FILE__). DIRECTORY_SEPARATOR . 'language'. DIRECTORY_SEPARATOR;
1421         }
1422         $foundlang = true;
1423         $lang_file = $lang_path . 'phpmailer.lang-' . $langcode . '.php';
1424         if ($langcode != 'en') { // There is no English translation file
1425             // Make sure language file path is readable
1426             if (!is_readable($lang_file)) {
1427                 $foundlang = false;
1428             } else {
1429                 // Overwrite language-specific strings.
1430                 // This way we'll never have missing translations.
1431                 $foundlang = include $lang_file;
1432             }
1433         }
1434         $this->language = $PHPMAILER_LANG;
1435         return (boolean)$foundlang; // Returns false if language not found
1436     }
1437
1438     /**
1439      * Get the array of strings for the current language.
1440      * @return array
1441      */
1442     public function getTranslations()
1443     {
1444         return $this->language;
1445     }
1446
1447     /**
1448      * Create recipient headers.
1449      * @access public
1450      * @param string $type
1451      * @param array $addr An array of recipient,
1452      * where each recipient is a 2-element indexed array with element 0 containing an address
1453      * and element 1 containing a name, like:
1454      * array(array('joe@example.com', 'Joe User'), array('zoe@example.com', 'Zoe User'))
1455      * @return string
1456      */
1457     public function addrAppend($type, $addr)
1458     {
1459         $addresses = array();
1460         foreach ($addr as $address) {
1461             $addresses[] = $this->addrFormat($address);
1462         }
1463         return $type . ': ' . implode(', ', $addresses) . $this->LE;
1464     }
1465
1466     /**
1467      * Format an address for use in a message header.
1468      * @access public
1469      * @param array $addr A 2-element indexed array, element 0 containing an address, element 1 containing a name
1470      * like array('joe@example.com', 'Joe User')
1471      * @return string
1472      */
1473     public function addrFormat($addr)
1474     {
1475         if (empty($addr[1])) { // No name provided
1476             return $this->secureHeader($addr[0]);
1477         } else {
1478             return $this->encodeHeader($this->secureHeader($addr[1]), 'phrase') . ' <' . $this->secureHeader(
1479                 $addr[0]
1480             ) . '>';
1481         }
1482     }
1483
1484     /**
1485      * Word-wrap message.
1486      * For use with mailers that do not automatically perform wrapping
1487      * and for quoted-printable encoded messages.
1488      * Original written by philippe.
1489      * @param string $message The message to wrap
1490      * @param integer $length The line length to wrap to
1491      * @param boolean $qp_mode Whether to run in Quoted-Printable mode
1492      * @access public
1493      * @return string
1494      */
1495     public function wrapText($message, $length, $qp_mode = false)
1496     {
1497         $soft_break = ($qp_mode) ? sprintf(' =%s', $this->LE) : $this->LE;
1498         // If utf-8 encoding is used, we will need to make sure we don't
1499         // split multibyte characters when we wrap
1500         $is_utf8 = (strtolower($this->CharSet) == 'utf-8');
1501         $lelen = strlen($this->LE);
1502         $crlflen = strlen(self::CRLF);
1503
1504         $message = $this->fixEOL($message);
1505         if (substr($message, -$lelen) == $this->LE) {
1506             $message = substr($message, 0, -$lelen);
1507         }
1508
1509         $line = explode($this->LE, $message); // Magic. We know fixEOL uses $LE
1510         $message = '';
1511         for ($i = 0; $i < count($line); $i++) {
1512             $line_part = explode(' ', $line[$i]);
1513             $buf = '';
1514             for ($e = 0; $e < count($line_part); $e++) {
1515                 $word = $line_part[$e];
1516                 if ($qp_mode and (strlen($word) > $length)) {
1517                     $space_left = $length - strlen($buf) - $crlflen;
1518                     if ($e != 0) {
1519                         if ($space_left > 20) {
1520                             $len = $space_left;
1521                             if ($is_utf8) {
1522                                 $len = $this->utf8CharBoundary($word, $len);
1523                             } elseif (substr($word, $len - 1, 1) == '=') {
1524                                 $len--;
1525                             } elseif (substr($word, $len - 2, 1) == '=') {
1526                                 $len -= 2;
1527                             }
1528                             $part = substr($word, 0, $len);
1529                             $word = substr($word, $len);
1530                             $buf .= ' ' . $part;
1531                             $message .= $buf . sprintf('=%s', self::CRLF);
1532                         } else {
1533                             $message .= $buf . $soft_break;
1534                         }
1535                         $buf = '';
1536                     }
1537                     while (strlen($word) > 0) {
1538                         if ($length <= 0) {
1539                             break;
1540                         }
1541                         $len = $length;
1542                         if ($is_utf8) {
1543                             $len = $this->utf8CharBoundary($word, $len);
1544                         } elseif (substr($word, $len - 1, 1) == '=') {
1545                             $len--;
1546                         } elseif (substr($word, $len - 2, 1) == '=') {
1547                             $len -= 2;
1548                         }
1549                         $part = substr($word, 0, $len);
1550                         $word = substr($word, $len);
1551
1552                         if (strlen($word) > 0) {
1553                             $message .= $part . sprintf('=%s', self::CRLF);
1554                         } else {
1555                             $buf = $part;
1556                         }
1557                     }
1558                 } else {
1559                     $buf_o = $buf;
1560                     $buf .= ($e == 0) ? $word : (' ' . $word);
1561
1562                     if (strlen($buf) > $length and $buf_o != '') {
1563                         $message .= $buf_o . $soft_break;
1564                         $buf = $word;
1565                     }
1566                 }
1567             }
1568             $message .= $buf . self::CRLF;
1569         }
1570
1571         return $message;
1572     }
1573
1574     /**
1575      * Find the last character boundary prior to $maxLength in a utf-8
1576      * quoted (printable) encoded string.
1577      * Original written by Colin Brown.
1578      * @access public
1579      * @param string $encodedText utf-8 QP text
1580      * @param integer $maxLength find last character boundary prior to this length
1581      * @return integer
1582      */
1583     public function utf8CharBoundary($encodedText, $maxLength)
1584     {
1585         $foundSplitPos = false;
1586         $lookBack = 3;
1587         while (!$foundSplitPos) {
1588             $lastChunk = substr($encodedText, $maxLength - $lookBack, $lookBack);
1589             $encodedCharPos = strpos($lastChunk, '=');
1590             if (false !== $encodedCharPos) {
1591                 // Found start of encoded character byte within $lookBack block.
1592                 // Check the encoded byte value (the 2 chars after the '=')
1593                 $hex = substr($encodedText, $maxLength - $lookBack + $encodedCharPos + 1, 2);
1594                 $dec = hexdec($hex);
1595                 if ($dec < 128) { // Single byte character.
1596                     // If the encoded char was found at pos 0, it will fit
1597                     // otherwise reduce maxLength to start of the encoded char
1598                     $maxLength = ($encodedCharPos == 0) ? $maxLength :
1599                         $maxLength - ($lookBack - $encodedCharPos);
1600                     $foundSplitPos = true;
1601                 } elseif ($dec >= 192) { // First byte of a multi byte character
1602                     // Reduce maxLength to split at start of character
1603                     $maxLength = $maxLength - ($lookBack - $encodedCharPos);
1604                     $foundSplitPos = true;
1605                 } elseif ($dec < 192) { // Middle byte of a multi byte character, look further back
1606                     $lookBack += 3;
1607                 }
1608             } else {
1609                 // No encoded character found
1610                 $foundSplitPos = true;
1611             }
1612         }
1613         return $maxLength;
1614     }
1615
1616     /**
1617      * Set the body wrapping.
1618      * @access public
1619      * @return void
1620      */
1621     public function setWordWrap()
1622     {
1623         if ($this->WordWrap < 1) {
1624             return;
1625         }
1626
1627         switch ($this->message_type) {
1628             case 'alt':
1629             case 'alt_inline':
1630             case 'alt_attach':
1631             case 'alt_inline_attach':
1632                 $this->AltBody = $this->wrapText($this->AltBody, $this->WordWrap);
1633                 break;
1634             default:
1635                 $this->Body = $this->wrapText($this->Body, $this->WordWrap);
1636                 break;
1637         }
1638     }
1639
1640     /**
1641      * Assemble message headers.
1642      * @access public
1643      * @return string The assembled headers
1644      */
1645     public function createHeader()
1646     {
1647         $result = '';
1648
1649         // Set the boundaries
1650         $uniq_id = md5(uniqid(time()));
1651         $this->boundary[1] = 'b1_' . $uniq_id;
1652         $this->boundary[2] = 'b2_' . $uniq_id;
1653         $this->boundary[3] = 'b3_' . $uniq_id;
1654
1655         if ($this->MessageDate == '') {
1656             $this->MessageDate = self::rfcDate();
1657         }
1658         $result .= $this->headerLine('Date', $this->MessageDate);
1659
1660
1661         // To be created automatically by mail()
1662         if ($this->SingleTo) {
1663             if ($this->Mailer != 'mail') {
1664                 foreach ($this->to as $toaddr) {
1665                     $this->SingleToArray[] = $this->addrFormat($toaddr);
1666                 }
1667             }
1668         } else {
1669             if (count($this->to) > 0) {
1670                 if ($this->Mailer != 'mail') {
1671                     $result .= $this->addrAppend('To', $this->to);
1672                 }
1673             } elseif (count($this->cc) == 0) {
1674                 $result .= $this->headerLine('To', 'undisclosed-recipients:;');
1675             }
1676         }
1677
1678         $result .= $this->addrAppend('From', array(array(trim($this->From), $this->FromName)));
1679
1680         // sendmail and mail() extract Cc from the header before sending
1681         if (count($this->cc) > 0) {
1682             $result .= $this->addrAppend('Cc', $this->cc);
1683         }
1684
1685         // sendmail and mail() extract Bcc from the header before sending
1686         if ((
1687                 $this->Mailer == 'sendmail' or $this->Mailer == 'qmail' or $this->Mailer == 'mail'
1688             )
1689             and count($this->bcc) > 0
1690         ) {
1691             $result .= $this->addrAppend('Bcc', $this->bcc);
1692         }
1693
1694         if (count($this->ReplyTo) > 0) {
1695             $result .= $this->addrAppend('Reply-To', $this->ReplyTo);
1696         }
1697
1698         // mail() sets the subject itself
1699         if ($this->Mailer != 'mail') {
1700             $result .= $this->headerLine('Subject', $this->encodeHeader($this->secureHeader($this->Subject)));
1701         }
1702
1703         if ($this->MessageID != '') {
1704             $this->lastMessageID = $this->MessageID;
1705         } else {
1706             $this->lastMessageID = sprintf('<%s@%s>', $uniq_id, $this->ServerHostname());
1707         }
1708         $result .= $this->HeaderLine('Message-ID', $this->lastMessageID);
1709         $result .= $this->headerLine('X-Priority', $this->Priority);
1710         if ($this->XMailer == '') {
1711             $result .= $this->headerLine(
1712                 'X-Mailer',
1713                 'PHPMailer ' . $this->Version . ' (https://github.com/PHPMailer/PHPMailer/)'
1714             );
1715         } else {
1716             $myXmailer = trim($this->XMailer);
1717             if ($myXmailer) {
1718                 $result .= $this->headerLine('X-Mailer', $myXmailer);
1719             }
1720         }
1721
1722         if ($this->ConfirmReadingTo != '') {
1723             $result .= $this->headerLine('Disposition-Notification-To', '<' . trim($this->ConfirmReadingTo) . '>');
1724         }
1725
1726         // Add custom headers
1727         for ($index = 0; $index < count($this->CustomHeader); $index++) {
1728             $result .= $this->headerLine(
1729                 trim($this->CustomHeader[$index][0]),
1730                 $this->encodeHeader(trim($this->CustomHeader[$index][1]))
1731             );
1732         }
1733         if (!$this->sign_key_file) {
1734             $result .= $this->headerLine('MIME-Version', '1.0');
1735             $result .= $this->getMailMIME();
1736         }
1737
1738         return $result;
1739     }
1740
1741     /**
1742      * Get the message MIME type headers.
1743      * @access public
1744      * @return string
1745      */
1746     public function getMailMIME()
1747     {
1748         $result = '';
1749         $ismultipart = true;
1750         switch ($this->message_type) {
1751             case 'inline':
1752                 $result .= $this->headerLine('Content-Type', 'multipart/related;');
1753                 $result .= $this->textLine("\tboundary=\"" . $this->boundary[1] . '"');
1754                 break;
1755             case 'attach':
1756             case 'inline_attach':
1757             case 'alt_attach':
1758             case 'alt_inline_attach':
1759                 $result .= $this->headerLine('Content-Type', 'multipart/mixed;');
1760                 $result .= $this->textLine("\tboundary=\"" . $this->boundary[1] . '"');
1761                 break;
1762             case 'alt':
1763             case 'alt_inline':
1764                 $result .= $this->headerLine('Content-Type', 'multipart/alternative;');
1765                 $result .= $this->textLine("\tboundary=\"" . $this->boundary[1] . '"');
1766                 break;
1767             default:
1768                 // Catches case 'plain': and case '':
1769                 $result .= $this->textLine('Content-Type: ' . $this->ContentType . '; charset=' . $this->CharSet);
1770                 $ismultipart = false;
1771                 break;
1772         }
1773         // RFC1341 part 5 says 7bit is assumed if not specified
1774         if ($this->Encoding != '7bit') {
1775             // RFC 2045 section 6.4 says multipart MIME parts may only use 7bit, 8bit or binary CTE
1776             if ($ismultipart) {
1777                 if ($this->Encoding == '8bit') {
1778                     $result .= $this->headerLine('Content-Transfer-Encoding', '8bit');
1779                 }
1780                 // The only remaining alternatives are quoted-printable and base64, which are both 7bit compatible
1781             } else {
1782                 $result .= $this->headerLine('Content-Transfer-Encoding', $this->Encoding);
1783             }
1784         }
1785
1786         if ($this->Mailer != 'mail') {
1787             $result .= $this->LE;
1788         }
1789
1790         return $result;
1791     }
1792
1793     /**
1794      * Returns the whole MIME message.
1795      * Includes complete headers and body.
1796      * Only valid post preSend().
1797      * @see PHPMailer::preSend()
1798      * @access public
1799      * @return string
1800      */
1801     public function getSentMIMEMessage()
1802     {
1803         return $this->MIMEHeader . $this->mailHeader . self::CRLF . $this->MIMEBody;
1804     }
1805
1806
1807     /**
1808      * Assemble the message body.
1809      * Returns an empty string on failure.
1810      * @access public
1811      * @throws phpmailerException
1812      * @return string The assembled message body
1813      */
1814     public function createBody()
1815     {
1816         $body = '';
1817
1818         if ($this->sign_key_file) {
1819             $body .= $this->getMailMIME() . $this->LE;
1820         }
1821
1822         $this->setWordWrap();
1823
1824         $bodyEncoding = $this->Encoding;
1825         $bodyCharSet = $this->CharSet;
1826         if ($bodyEncoding == '8bit' and !$this->has8bitChars($this->Body)) {
1827             $bodyEncoding = '7bit';
1828             $bodyCharSet = 'us-ascii';
1829         }
1830         $altBodyEncoding = $this->Encoding;
1831         $altBodyCharSet = $this->CharSet;
1832         if ($altBodyEncoding == '8bit' and !$this->has8bitChars($this->AltBody)) {
1833             $altBodyEncoding = '7bit';
1834             $altBodyCharSet = 'us-ascii';
1835         }
1836         switch ($this->message_type) {
1837             case 'inline':
1838                 $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, '', $bodyEncoding);
1839                 $body .= $this->encodeString($this->Body, $bodyEncoding);
1840                 $body .= $this->LE . $this->LE;
1841                 $body .= $this->attachAll('inline', $this->boundary[1]);
1842                 break;
1843             case 'attach':
1844                 $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, '', $bodyEncoding);
1845                 $body .= $this->encodeString($this->Body, $bodyEncoding);
1846                 $body .= $this->LE . $this->LE;
1847                 $body .= $this->attachAll('attachment', $this->boundary[1]);
1848                 break;
1849             case 'inline_attach':
1850                 $body .= $this->textLine('--' . $this->boundary[1]);
1851                 $body .= $this->headerLine('Content-Type', 'multipart/related;');
1852                 $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1853                 $body .= $this->LE;
1854                 $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, '', $bodyEncoding);
1855                 $body .= $this->encodeString($this->Body, $bodyEncoding);
1856                 $body .= $this->LE . $this->LE;
1857                 $body .= $this->attachAll('inline', $this->boundary[2]);
1858                 $body .= $this->LE;
1859                 $body .= $this->attachAll('attachment', $this->boundary[1]);
1860                 break;
1861             case 'alt':
1862                 $body .= $this->getBoundary($this->boundary[1], $altBodyCharSet, 'text/plain', $altBodyEncoding);
1863                 $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
1864                 $body .= $this->LE . $this->LE;
1865                 $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, 'text/html', $bodyEncoding);
1866                 $body .= $this->encodeString($this->Body, $bodyEncoding);
1867                 $body .= $this->LE . $this->LE;
1868                 if (!empty($this->Ical)) {
1869                     $body .= $this->getBoundary($this->boundary[1], '', 'text/calendar; method=REQUEST', '');
1870                     $body .= $this->encodeString($this->Ical, $this->Encoding);
1871                     $body .= $this->LE . $this->LE;
1872                 }
1873                 $body .= $this->endBoundary($this->boundary[1]);
1874                 break;
1875             case 'alt_inline':
1876                 $body .= $this->getBoundary($this->boundary[1], $altBodyCharSet, 'text/plain', $altBodyEncoding);
1877                 $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
1878                 $body .= $this->LE . $this->LE;
1879                 $body .= $this->textLine('--' . $this->boundary[1]);
1880                 $body .= $this->headerLine('Content-Type', 'multipart/related;');
1881                 $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1882                 $body .= $this->LE;
1883                 $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, 'text/html', $bodyEncoding);
1884                 $body .= $this->encodeString($this->Body, $bodyEncoding);
1885                 $body .= $this->LE . $this->LE;
1886                 $body .= $this->attachAll('inline', $this->boundary[2]);
1887                 $body .= $this->LE;
1888                 $body .= $this->endBoundary($this->boundary[1]);
1889                 break;
1890             case 'alt_attach':
1891                 $body .= $this->textLine('--' . $this->boundary[1]);
1892                 $body .= $this->headerLine('Content-Type', 'multipart/alternative;');
1893                 $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1894                 $body .= $this->LE;
1895                 $body .= $this->getBoundary($this->boundary[2], $altBodyCharSet, 'text/plain', $altBodyEncoding);
1896                 $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
1897                 $body .= $this->LE . $this->LE;
1898                 $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, 'text/html', $bodyEncoding);
1899                 $body .= $this->encodeString($this->Body, $bodyEncoding);
1900                 $body .= $this->LE . $this->LE;
1901                 $body .= $this->endBoundary($this->boundary[2]);
1902                 $body .= $this->LE;
1903                 $body .= $this->attachAll('attachment', $this->boundary[1]);
1904                 break;
1905             case 'alt_inline_attach':
1906                 $body .= $this->textLine('--' . $this->boundary[1]);
1907                 $body .= $this->headerLine('Content-Type', 'multipart/alternative;');
1908                 $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1909                 $body .= $this->LE;
1910                 $body .= $this->getBoundary($this->boundary[2], $altBodyCharSet, 'text/plain', $altBodyEncoding);
1911                 $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
1912                 $body .= $this->LE . $this->LE;
1913                 $body .= $this->textLine('--' . $this->boundary[2]);
1914                 $body .= $this->headerLine('Content-Type', 'multipart/related;');
1915                 $body .= $this->textLine("\tboundary=\"" . $this->boundary[3] . '"');
1916                 $body .= $this->LE;
1917                 $body .= $this->getBoundary($this->boundary[3], $bodyCharSet, 'text/html', $bodyEncoding);
1918                 $body .= $this->encodeString($this->Body, $bodyEncoding);
1919                 $body .= $this->LE . $this->LE;
1920                 $body .= $this->attachAll('inline', $this->boundary[3]);
1921                 $body .= $this->LE;
1922                 $body .= $this->endBoundary($this->boundary[2]);
1923                 $body .= $this->LE;
1924                 $body .= $this->attachAll('attachment', $this->boundary[1]);
1925                 break;
1926             default:
1927                 // catch case 'plain' and case ''
1928                 $body .= $this->encodeString($this->Body, $bodyEncoding);
1929                 break;
1930         }
1931
1932         if ($this->isError()) {
1933             $body = '';
1934         } elseif ($this->sign_key_file) {
1935             try {
1936                 if (!defined('PKCS7_TEXT')) {
1937                     throw new phpmailerException($this->lang('signing') . ' OpenSSL extension missing.');
1938                 }
1939                 // @TODO would be nice to use php://temp streams here, but need to wrap for PHP < 5.1
1940                 $file = tempnam(sys_get_temp_dir(), 'mail');
1941                 if (false === file_put_contents($file, $body)) {
1942                     throw new phpmailerException($this->lang('signing') . ' Could not write temp file');
1943                 }
1944                 $signed = tempnam(sys_get_temp_dir(), 'signed');
1945                 if (@openssl_pkcs7_sign(
1946                     $file,
1947                     $signed,
1948                     'file://' . realpath($this->sign_cert_file),
1949                     array('file://' . realpath($this->sign_key_file), $this->sign_key_pass),
1950                     null
1951                 )
1952                 ) {
1953                     @unlink($file);
1954                     $body = file_get_contents($signed);
1955                     @unlink($signed);
1956                 } else {
1957                     @unlink($file);
1958                     @unlink($signed);
1959                     throw new phpmailerException($this->lang('signing') . openssl_error_string());
1960                 }
1961             } catch (phpmailerException $exc) {
1962                 $body = '';
1963                 if ($this->exceptions) {
1964                     throw $exc;
1965                 }
1966             }
1967         }
1968         return $body;
1969     }
1970
1971     /**
1972      * Return the start of a message boundary.
1973      * @access protected
1974      * @param string $boundary
1975      * @param string $charSet
1976      * @param string $contentType
1977      * @param string $encoding
1978      * @return string
1979      */
1980     protected function getBoundary($boundary, $charSet, $contentType, $encoding)
1981     {
1982         $result = '';
1983         if ($charSet == '') {
1984             $charSet = $this->CharSet;
1985         }
1986         if ($contentType == '') {
1987             $contentType = $this->ContentType;
1988         }
1989         if ($encoding == '') {
1990             $encoding = $this->Encoding;
1991         }
1992         $result .= $this->textLine('--' . $boundary);
1993         $result .= sprintf('Content-Type: %s; charset=%s', $contentType, $charSet);
1994         $result .= $this->LE;
1995         // RFC1341 part 5 says 7bit is assumed if not specified
1996         if ($encoding != '7bit') {
1997             $result .= $this->headerLine('Content-Transfer-Encoding', $encoding);
1998         }
1999         $result .= $this->LE;
2000
2001         return $result;
2002     }
2003
2004     /**
2005      * Return the end of a message boundary.
2006      * @access protected
2007      * @param string $boundary
2008      * @return string
2009      */
2010     protected function endBoundary($boundary)
2011     {
2012         return $this->LE . '--' . $boundary . '--' . $this->LE;
2013     }
2014
2015     /**
2016      * Set the message type.
2017      * PHPMailer only supports some preset message types,
2018      * not arbitrary MIME structures.
2019      * @access protected
2020      * @return void
2021      */
2022     protected function setMessageType()
2023     {
2024         $type = array();
2025         if ($this->alternativeExists()) {
2026             $type[] = 'alt';
2027         }
2028         if ($this->inlineImageExists()) {
2029             $type[] = 'inline';
2030         }
2031         if ($this->attachmentExists()) {
2032             $type[] = 'attach';
2033         }
2034         $this->message_type = implode('_', $type);
2035         if ($this->message_type == '') {
2036             $this->message_type = 'plain';
2037         }
2038     }
2039
2040     /**
2041      * Format a header line.
2042      * @access public
2043      * @param string $name
2044      * @param string $value
2045      * @return string
2046      */
2047     public function headerLine($name, $value)
2048     {
2049         return $name . ': ' . $value . $this->LE;
2050     }
2051
2052     /**
2053      * Return a formatted mail line.
2054      * @access public
2055      * @param string $value
2056      * @return string
2057      */
2058     public function textLine($value)
2059     {
2060         return $value . $this->LE;
2061     }
2062
2063     /**
2064      * Add an attachment from a path on the filesystem.
2065      * Returns false if the file could not be found or read.
2066      * @param string $path Path to the attachment.
2067      * @param string $name Overrides the attachment name.
2068      * @param string $encoding File encoding (see $Encoding).
2069      * @param string $type File extension (MIME) type.
2070      * @param string $disposition Disposition to use
2071      * @throws phpmailerException
2072      * @return boolean
2073      */
2074     public function addAttachment($path, $name = '', $encoding = 'base64', $type = '', $disposition = 'attachment')
2075     {
2076         try {
2077             if (!@is_file($path)) {
2078                 throw new phpmailerException($this->lang('file_access') . $path, self::STOP_CONTINUE);
2079             }
2080
2081             // If a MIME type is not specified, try to work it out from the file name
2082             if ($type == '') {
2083                 $type = self::filenameToType($path);
2084             }
2085
2086             $filename = basename($path);
2087             if ($name == '') {
2088                 $name = $filename;
2089             }
2090
2091             $this->attachment[] = array(
2092                 0 => $path,
2093                 1 => $filename,
2094                 2 => $name,
2095                 3 => $encoding,
2096                 4 => $type,
2097                 5 => false, // isStringAttachment
2098                 6 => $disposition,
2099                 7 => 0
2100             );
2101
2102         } catch (phpmailerException $exc) {
2103             $this->setError($exc->getMessage());
2104             $this->edebug($exc->getMessage());
2105             if ($this->exceptions) {
2106                 throw $exc;
2107             }
2108             return false;
2109         }
2110         return true;
2111     }
2112
2113     /**
2114      * Return the array of attachments.
2115      * @return array
2116      */
2117     public function getAttachments()
2118     {
2119         return $this->attachment;
2120     }
2121
2122     /**
2123      * Attach all file, string, and binary attachments to the message.
2124      * Returns an empty string on failure.
2125      * @access protected
2126      * @param string $disposition_type
2127      * @param string $boundary
2128      * @return string
2129      */
2130     protected function attachAll($disposition_type, $boundary)
2131     {
2132         // Return text of body
2133         $mime = array();
2134         $cidUniq = array();
2135         $incl = array();
2136
2137         // Add all attachments
2138         foreach ($this->attachment as $attachment) {
2139             // Check if it is a valid disposition_filter
2140             if ($attachment[6] == $disposition_type) {
2141                 // Check for string attachment
2142                 $string = '';
2143                 $path = '';
2144                 $bString = $attachment[5];
2145                 if ($bString) {
2146                     $string = $attachment[0];
2147                 } else {
2148                     $path = $attachment[0];
2149                 }
2150
2151                 $inclhash = md5(serialize($attachment));
2152                 if (in_array($inclhash, $incl)) {
2153                     continue;
2154                 }
2155                 $incl[] = $inclhash;
2156                 $name = $attachment[2];
2157                 $encoding = $attachment[3];
2158                 $type = $attachment[4];
2159                 $disposition = $attachment[6];
2160                 $cid = $attachment[7];
2161                 if ($disposition == 'inline' && isset($cidUniq[$cid])) {
2162                     continue;
2163                 }
2164                 $cidUniq[$cid] = true;
2165
2166                 $mime[] = sprintf('--%s%s', $boundary, $this->LE);
2167                 $mime[] = sprintf(
2168                     'Content-Type: %s; name="%s"%s',
2169                     $type,
2170                     $this->encodeHeader($this->secureHeader($name)),
2171                     $this->LE
2172                 );
2173                 // RFC1341 part 5 says 7bit is assumed if not specified
2174                 if ($encoding != '7bit') {
2175                     $mime[] = sprintf('Content-Transfer-Encoding: %s%s', $encoding, $this->LE);
2176                 }
2177
2178                 if ($disposition == 'inline') {
2179                     $mime[] = sprintf('Content-ID: <%s>%s', $cid, $this->LE);
2180                 }
2181
2182                 // If a filename contains any of these chars, it should be quoted,
2183                 // but not otherwise: RFC2183 & RFC2045 5.1
2184                 // Fixes a warning in IETF's msglint MIME checker
2185                 // Allow for bypassing the Content-Disposition header totally
2186                 if (!(empty($disposition))) {
2187                     $encoded_name = $this->encodeHeader($this->secureHeader($name));
2188                     if (preg_match('/[ \(\)<>@,;:\\"\/\[\]\?=]/', $encoded_name)) {
2189                         $mime[] = sprintf(
2190                             'Content-Disposition: %s; filename="%s"%s',
2191                             $disposition,
2192                             $encoded_name,
2193                             $this->LE . $this->LE
2194                         );
2195                     } else {
2196                         $mime[] = sprintf(
2197                             'Content-Disposition: %s; filename=%s%s',
2198                             $disposition,
2199                             $encoded_name,
2200                             $this->LE . $this->LE
2201                         );
2202                     }
2203                 } else {
2204                     $mime[] = $this->LE;
2205                 }
2206
2207                 // Encode as string attachment
2208                 if ($bString) {
2209                     $mime[] = $this->encodeString($string, $encoding);
2210                     if ($this->isError()) {
2211                         return '';
2212                     }
2213                     $mime[] = $this->LE . $this->LE;
2214                 } else {
2215                     $mime[] = $this->encodeFile($path, $encoding);
2216                     if ($this->isError()) {
2217                         return '';
2218                     }
2219                     $mime[] = $this->LE . $this->LE;
2220                 }
2221             }
2222         }
2223
2224         $mime[] = sprintf('--%s--%s', $boundary, $this->LE);
2225
2226         return implode('', $mime);
2227     }
2228
2229     /**
2230      * Encode a file attachment in requested format.
2231      * Returns an empty string on failure.
2232      * @param string $path The full path to the file
2233      * @param string $encoding The encoding to use; one of 'base64', '7bit', '8bit', 'binary', 'quoted-printable'
2234      * @throws phpmailerException
2235      * @see EncodeFile(encodeFile
2236      * @access protected
2237      * @return string
2238      */
2239     protected function encodeFile($path, $encoding = 'base64')
2240     {
2241         try {
2242             if (!is_readable($path)) {
2243                 throw new phpmailerException($this->lang('file_open') . $path, self::STOP_CONTINUE);
2244             }
2245             $magic_quotes = get_magic_quotes_runtime();
2246             if ($magic_quotes) {
2247                 if (version_compare(PHP_VERSION, '5.3.0', '<')) {
2248                     set_magic_quotes_runtime(false);
2249                 } else {
2250                     //Doesn't exist in PHP 5.4, but we don't need to check because
2251                     //get_magic_quotes_runtime always returns false in 5.4+
2252                     //so it will never get here
2253                     ini_set('magic_quotes_runtime', 0);
2254                 }
2255             }
2256             $file_buffer = file_get_contents($path);
2257             $file_buffer = $this->encodeString($file_buffer, $encoding);
2258             if ($magic_quotes) {
2259                 if (version_compare(PHP_VERSION, '5.3.0', '<')) {
2260                     set_magic_quotes_runtime($magic_quotes);
2261                 } else {
2262                     ini_set('magic_quotes_runtime', ($magic_quotes?'1':'0'));
2263                 }
2264             }
2265             return $file_buffer;
2266         } catch (Exception $exc) {
2267             $this->setError($exc->getMessage());
2268             return '';
2269         }
2270     }
2271
2272     /**
2273      * Encode a string in requested format.
2274      * Returns an empty string on failure.
2275      * @param string $str The text to encode
2276      * @param string $encoding The encoding to use; one of 'base64', '7bit', '8bit', 'binary', 'quoted-printable'
2277      * @access public
2278      * @return string
2279      */
2280     public function encodeString($str, $encoding = 'base64')
2281     {
2282         $encoded = '';
2283         switch (strtolower($encoding)) {
2284             case 'base64':
2285                 $encoded = chunk_split(base64_encode($str), 76, $this->LE);
2286                 break;
2287             case '7bit':
2288             case '8bit':
2289                 $encoded = $this->fixEOL($str);
2290                 // Make sure it ends with a line break
2291                 if (substr($encoded, -(strlen($this->LE))) != $this->LE) {
2292                     $encoded .= $this->LE;
2293                 }
2294                 break;
2295             case 'binary':
2296                 $encoded = $str;
2297                 break;
2298             case 'quoted-printable':
2299                 $encoded = $this->encodeQP($str);
2300                 break;
2301             default:
2302                 $this->setError($this->lang('encoding') . $encoding);
2303                 break;
2304         }
2305         return $encoded;
2306     }
2307
2308     /**
2309      * Encode a header string optimally.
2310      * Picks shortest of Q, B, quoted-printable or none.
2311      * @access public
2312      * @param string $str
2313      * @param string $position
2314      * @return string
2315      */
2316     public function encodeHeader($str, $position = 'text')
2317     {
2318         $matchcount = 0;
2319         switch (strtolower($position)) {
2320             case 'phrase':
2321                 if (!preg_match('/[\200-\377]/', $str)) {
2322                     // Can't use addslashes as we don't know the value of magic_quotes_sybase
2323                     $encoded = addcslashes($str, "\0..\37\177\\\"");
2324                     if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str)) {
2325                         return ($encoded);
2326                     } else {
2327                         return ("\"$encoded\"");
2328                     }
2329                 }
2330                 $matchcount = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
2331                 break;
2332             /** @noinspection PhpMissingBreakStatementInspection */
2333             case 'comment':
2334                 $matchcount = preg_match_all('/[()"]/', $str, $matches);
2335                 // Intentional fall-through
2336             case 'text':
2337             default:
2338                 $matchcount += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
2339                 break;
2340         }
2341
2342         if ($matchcount == 0) { // There are no chars that need encoding
2343             return ($str);
2344         }
2345
2346         $maxlen = 75 - 7 - strlen($this->CharSet);
2347         // Try to select the encoding which should produce the shortest output
2348         if ($matchcount > strlen($str) / 3) {
2349             // More than a third of the content will need encoding, so B encoding will be most efficient
2350             $encoding = 'B';
2351             if (function_exists('mb_strlen') && $this->hasMultiBytes($str)) {
2352                 // Use a custom function which correctly encodes and wraps long
2353                 // multibyte strings without breaking lines within a character
2354                 $encoded = $this->base64EncodeWrapMB($str, "\n");
2355             } else {
2356                 $encoded = base64_encode($str);
2357                 $maxlen -= $maxlen % 4;
2358                 $encoded = trim(chunk_split($encoded, $maxlen, "\n"));
2359             }
2360         } else {
2361             $encoding = 'Q';
2362             $encoded = $this->encodeQ($str, $position);
2363             $encoded = $this->wrapText($encoded, $maxlen, true);
2364             $encoded = str_replace('=' . self::CRLF, "\n", trim($encoded));
2365         }
2366
2367         $encoded = preg_replace('/^(.*)$/m', ' =?' . $this->CharSet . "?$encoding?\\1?=", $encoded);
2368         $encoded = trim(str_replace("\n", $this->LE, $encoded));
2369
2370         return $encoded;
2371     }
2372
2373     /**
2374      * Check if a string contains multi-byte characters.
2375      * @access public
2376      * @param string $str multi-byte text to wrap encode
2377      * @return boolean
2378      */
2379     public function hasMultiBytes($str)
2380     {
2381         if (function_exists('mb_strlen')) {
2382             return (strlen($str) > mb_strlen($str, $this->CharSet));
2383         } else { // Assume no multibytes (we can't handle without mbstring functions anyway)
2384             return false;
2385         }
2386     }
2387
2388     /**
2389      * Does a string contain any 8-bit chars (in any charset)?
2390      * @param string $text
2391      * @return boolean
2392      */
2393     public function has8bitChars($text)
2394     {
2395         return (boolean)preg_match('/[\x80-\xFF]/', $text);
2396     }
2397
2398     /**
2399      * Encode and wrap long multibyte strings for mail headers
2400      * without breaking lines within a character.
2401      * Adapted from a function by paravoid
2402      * @link http://www.php.net/manual/en/function.mb-encode-mimeheader.php#60283
2403      * @access public
2404      * @param string $str multi-byte text to wrap encode
2405      * @param string $linebreak string to use as linefeed/end-of-line
2406      * @return string
2407      */
2408     public function base64EncodeWrapMB($str, $linebreak = null)
2409     {
2410         $start = '=?' . $this->CharSet . '?B?';
2411         $end = '?=';
2412         $encoded = '';
2413         if ($linebreak === null) {
2414             $linebreak = $this->LE;
2415         }
2416
2417         $mb_length = mb_strlen($str, $this->CharSet);
2418         // Each line must have length <= 75, including $start and $end
2419         $length = 75 - strlen($start) - strlen($end);
2420         // Average multi-byte ratio
2421         $ratio = $mb_length / strlen($str);
2422         // Base64 has a 4:3 ratio
2423         $avgLength = floor($length * $ratio * .75);
2424
2425         for ($i = 0; $i < $mb_length; $i += $offset) {
2426             $lookBack = 0;
2427             do {
2428                 $offset = $avgLength - $lookBack;
2429                 $chunk = mb_substr($str, $i, $offset, $this->CharSet);
2430                 $chunk = base64_encode($chunk);
2431                 $lookBack++;
2432             } while (strlen($chunk) > $length);
2433             $encoded .= $chunk . $linebreak;
2434         }
2435
2436         // Chomp the last linefeed
2437         $encoded = substr($encoded, 0, -strlen($linebreak));
2438         return $encoded;
2439     }
2440
2441     /**
2442      * Encode a string in quoted-printable format.
2443      * According to RFC2045 section 6.7.
2444      * @access public
2445      * @param string $string The text to encode
2446      * @param integer $line_max Number of chars allowed on a line before wrapping
2447      * @return string
2448      * @link http://www.php.net/manual/en/function.quoted-printable-decode.php#89417 Adapted from this comment
2449      */
2450     public function encodeQP($string, $line_max = 76)
2451     {
2452         if (function_exists('quoted_printable_encode')) { // Use native function if it's available (>= PHP5.3)
2453             return $this->fixEOL(quoted_printable_encode($string));
2454         }
2455         // Fall back to a pure PHP implementation
2456         $string = str_replace(
2457             array('%20', '%0D%0A.', '%0D%0A', '%'),
2458             array(' ', "\r\n=2E", "\r\n", '='),
2459             rawurlencode($string)
2460         );
2461         $string = preg_replace('/[^\r\n]{' . ($line_max - 3) . '}[^=\r\n]{2}/', "$0=\r\n", $string);
2462         return $this->fixEOL($string);
2463     }
2464
2465     /**
2466      * Backward compatibility wrapper for an old QP encoding function that was removed.
2467      * @see PHPMailer::encodeQP()
2468      * @access public
2469      * @param string $string
2470      * @param integer $line_max
2471      * @param boolean $space_conv
2472      * @return string
2473      * @deprecated Use encodeQP instead.
2474      */
2475     public function encodeQPphp(
2476         $string,
2477         $line_max = 76,
2478         /** @noinspection PhpUnusedParameterInspection */ $space_conv = false
2479     ) {
2480         return $this->encodeQP($string, $line_max);
2481     }
2482
2483     /**
2484      * Encode a string using Q encoding.
2485      * @link http://tools.ietf.org/html/rfc2047
2486      * @param string $str the text to encode
2487      * @param string $position Where the text is going to be used, see the RFC for what that means
2488      * @access public
2489      * @return string
2490      */
2491     public function encodeQ($str, $position = 'text')
2492     {
2493         // There should not be any EOL in the string
2494         $pattern = '';
2495         $encoded = str_replace(array("\r", "\n"), '', $str);
2496         switch (strtolower($position)) {
2497             case 'phrase':
2498                 // RFC 2047 section 5.3
2499                 $pattern = '^A-Za-z0-9!*+\/ -';
2500                 break;
2501             /** @noinspection PhpMissingBreakStatementInspection */
2502             case 'comment':
2503                 // RFC 2047 section 5.2
2504                 $pattern = '\(\)"';
2505                 // intentional fall-through
2506                 // for this reason we build the $pattern without including delimiters and []
2507             case 'text':
2508             default:
2509                 // RFC 2047 section 5.1
2510                 // Replace every high ascii, control, =, ? and _ characters
2511                 $pattern = '\000-\011\013\014\016-\037\075\077\137\177-\377' . $pattern;
2512                 break;
2513         }
2514         $matches = array();
2515         if (preg_match_all("/[{$pattern}]/", $encoded, $matches)) {
2516             // If the string contains an '=', make sure it's the first thing we replace
2517             // so as to avoid double-encoding
2518             $eqkey = array_search('=', $matches[0]);
2519             if (false !== $eqkey) {
2520                 unset($matches[0][$eqkey]);
2521                 array_unshift($matches[0], '=');
2522             }
2523             foreach (array_unique($matches[0]) as $char) {
2524                 $encoded = str_replace($char, '=' . sprintf('%02X', ord($char)), $encoded);
2525             }
2526         }
2527         // Replace every spaces to _ (more readable than =20)
2528         return str_replace(' ', '_', $encoded);
2529     }
2530
2531
2532     /**
2533      * Add a string or binary attachment (non-filesystem).
2534      * This method can be used to attach ascii or binary data,
2535      * such as a BLOB record from a database.
2536      * @param string $string String attachment data.
2537      * @param string $filename Name of the attachment.
2538      * @param string $encoding File encoding (see $Encoding).
2539      * @param string $type File extension (MIME) type.
2540      * @param string $disposition Disposition to use
2541      * @return void
2542      */
2543     public function addStringAttachment(
2544         $string,
2545         $filename,
2546         $encoding = 'base64',
2547         $type = '',
2548         $disposition = 'attachment'
2549     ) {
2550         // If a MIME type is not specified, try to work it out from the file name
2551         if ($type == '') {
2552             $type = self::filenameToType($filename);
2553         }
2554         // Append to $attachment array
2555         $this->attachment[] = array(
2556             0 => $string,
2557             1 => $filename,
2558             2 => basename($filename),
2559             3 => $encoding,
2560             4 => $type,
2561             5 => true, // isStringAttachment
2562             6 => $disposition,
2563             7 => 0
2564         );
2565     }
2566
2567     /**
2568      * Add an embedded (inline) attachment from a file.
2569      * This can include images, sounds, and just about any other document type.
2570      * These differ from 'regular' attachments in that they are intended to be
2571      * displayed inline with the message, not just attached for download.
2572      * This is used in HTML messages that embed the images
2573      * the HTML refers to using the $cid value.
2574      * @param string $path Path to the attachment.
2575      * @param string $cid Content ID of the attachment; Use this to reference
2576      * the content when using an embedded image in HTML.
2577      * @param string $name Overrides the attachment name.
2578      * @param string $encoding File encoding (see $Encoding).
2579      * @param string $type File MIME type.
2580      * @param string $disposition Disposition to use
2581      * @return boolean True on successfully adding an attachment
2582      */
2583     public function addEmbeddedImage($path, $cid, $name = '', $encoding = 'base64', $type = '', $disposition = 'inline')
2584     {
2585         if (!@is_file($path)) {
2586             $this->setError($this->lang('file_access') . $path);
2587             return false;
2588         }
2589
2590         // If a MIME type is not specified, try to work it out from the file name
2591         if ($type == '') {
2592             $type = self::filenameToType($path);
2593         }
2594
2595         $filename = basename($path);
2596         if ($name == '') {
2597             $name = $filename;
2598         }
2599
2600         // Append to $attachment array
2601         $this->attachment[] = array(
2602             0 => $path,
2603             1 => $filename,
2604             2 => $name,
2605             3 => $encoding,
2606             4 => $type,
2607             5 => false, // isStringAttachment
2608             6 => $disposition,
2609             7 => $cid
2610         );
2611         return true;
2612     }
2613
2614     /**
2615      * Add an embedded stringified attachment.
2616      * This can include images, sounds, and just about any other document type.
2617      * Be sure to set the $type to an image type for images:
2618      * JPEG images use 'image/jpeg', GIF uses 'image/gif', PNG uses 'image/png'.
2619      * @param string $string The attachment binary data.
2620      * @param string $cid Content ID of the attachment; Use this to reference
2621      * the content when using an embedded image in HTML.
2622      * @param string $name
2623      * @param string $encoding File encoding (see $Encoding).
2624      * @param string $type MIME type.
2625      * @param string $disposition Disposition to use
2626      * @return boolean True on successfully adding an attachment
2627      */
2628     public function addStringEmbeddedImage(
2629         $string,
2630         $cid,
2631         $name = '',
2632         $encoding = 'base64',
2633         $type = '',
2634         $disposition = 'inline'
2635     ) {
2636         // If a MIME type is not specified, try to work it out from the name
2637         if ($type == '') {
2638             $type = self::filenameToType($name);
2639         }
2640
2641         // Append to $attachment array
2642         $this->attachment[] = array(
2643             0 => $string,
2644             1 => $name,
2645             2 => $name,
2646             3 => $encoding,
2647             4 => $type,
2648             5 => true, // isStringAttachment
2649             6 => $disposition,
2650             7 => $cid
2651         );
2652         return true;
2653     }
2654
2655     /**
2656      * Check if an inline attachment is present.
2657      * @access public
2658      * @return boolean
2659      */
2660     public function inlineImageExists()
2661     {
2662         foreach ($this->attachment as $attachment) {
2663             if ($attachment[6] == 'inline') {
2664                 return true;
2665             }
2666         }
2667         return false;
2668     }
2669
2670     /**
2671      * Check if an attachment (non-inline) is present.
2672      * @return boolean
2673      */
2674     public function attachmentExists()
2675     {
2676         foreach ($this->attachment as $attachment) {
2677             if ($attachment[6] == 'attachment') {
2678                 return true;
2679             }
2680         }
2681         return false;
2682     }
2683
2684     /**
2685      * Check if this message has an alternative body set.
2686      * @return boolean
2687      */
2688     public function alternativeExists()
2689     {
2690         return !empty($this->AltBody);
2691     }
2692
2693     /**
2694      * Clear all To recipients.
2695      * @return void
2696      */
2697     public function clearAddresses()
2698     {
2699         foreach ($this->to as $to) {
2700             unset($this->all_recipients[strtolower($to[0])]);
2701         }
2702         $this->to = array();
2703     }
2704
2705     /**
2706      * Clear all CC recipients.
2707      * @return void
2708      */
2709     public function clearCCs()
2710     {
2711         foreach ($this->cc as $cc) {
2712             unset($this->all_recipients[strtolower($cc[0])]);
2713         }
2714         $this->cc = array();
2715     }
2716
2717     /**
2718      * Clear all BCC recipients.
2719      * @return void
2720      */
2721     public function clearBCCs()
2722     {
2723         foreach ($this->bcc as $bcc) {
2724             unset($this->all_recipients[strtolower($bcc[0])]);
2725         }
2726         $this->bcc = array();
2727     }
2728
2729     /**
2730      * Clear all ReplyTo recipients.
2731      * @return void
2732      */
2733     public function clearReplyTos()
2734     {
2735         $this->ReplyTo = array();
2736     }
2737
2738     /**
2739      * Clear all recipient types.
2740      * @return void
2741      */
2742     public function clearAllRecipients()
2743     {
2744         $this->to = array();
2745         $this->cc = array();
2746         $this->bcc = array();
2747         $this->all_recipients = array();
2748     }
2749
2750     /**
2751      * Clear all filesystem, string, and binary attachments.
2752      * @return void
2753      */
2754     public function clearAttachments()
2755     {
2756         $this->attachment = array();
2757     }
2758
2759     /**
2760      * Clear all custom headers.
2761      * @return void
2762      */
2763     public function clearCustomHeaders()
2764     {
2765         $this->CustomHeader = array();
2766     }
2767
2768     /**
2769      * Add an error message to the error container.
2770      * @access protected
2771      * @param string $msg
2772      * @return void
2773      */
2774     protected function setError($msg)
2775     {
2776         $this->error_count++;
2777         if ($this->Mailer == 'smtp' and !is_null($this->smtp)) {
2778             $lasterror = $this->smtp->getError();
2779             if (!empty($lasterror) and array_key_exists('smtp_msg', $lasterror)) {
2780                 $msg .= '<p>' . $this->lang('smtp_error') . $lasterror['smtp_msg'] . "</p>\n";
2781             }
2782         }
2783         $this->ErrorInfo = $msg;
2784     }
2785
2786     /**
2787      * Return an RFC 822 formatted date.
2788      * @access public
2789      * @return string
2790      * @static
2791      */
2792     public static function rfcDate()
2793     {
2794         // Set the time zone to whatever the default is to avoid 500 errors
2795         // Will default to UTC if it's not set properly in php.ini
2796         date_default_timezone_set(@date_default_timezone_get());
2797         return date('D, j M Y H:i:s O');
2798     }
2799
2800     /**
2801      * Get the server hostname.
2802      * Returns 'localhost.localdomain' if unknown.
2803      * @access protected
2804      * @return string
2805      */
2806     protected function serverHostname()
2807     {
2808         $result = 'localhost.localdomain';
2809         if (!empty($this->Hostname)) {
2810             $result = $this->Hostname;
2811         } elseif (isset($_SERVER) and array_key_exists('SERVER_NAME', $_SERVER) and !empty($_SERVER['SERVER_NAME'])) {
2812             $result = $_SERVER['SERVER_NAME'];
2813         } elseif (function_exists('gethostname') && gethostname() !== false) {
2814             $result = gethostname();
2815         } elseif (php_uname('n') !== false) {
2816             $result = php_uname('n');
2817         }
2818         return $result;
2819     }
2820
2821     /**
2822      * Get an error message in the current language.
2823      * @access protected
2824      * @param string $key
2825      * @return string
2826      */
2827     protected function lang($key)
2828     {
2829         if (count($this->language) < 1) {
2830             $this->setLanguage('en'); // set the default language
2831         }
2832
2833         if (isset($this->language[$key])) {
2834             return $this->language[$key];
2835         } else {
2836             return 'Language string failed to load: ' . $key;
2837         }
2838     }
2839
2840     /**
2841      * Check if an error occurred.
2842      * @access public
2843      * @return boolean True if an error did occur.
2844      */
2845     public function isError()
2846     {
2847         return ($this->error_count > 0);
2848     }
2849
2850     /**
2851      * Ensure consistent line endings in a string.
2852      * Changes every end of line from CRLF, CR or LF to $this->LE.
2853      * @access public
2854      * @param string $str String to fixEOL
2855      * @return string
2856      */
2857     public function fixEOL($str)
2858     {
2859         // Normalise to \n
2860         $nstr = str_replace(array("\r\n", "\r"), "\n", $str);
2861         // Now convert LE as needed
2862         if ($this->LE !== "\n") {
2863             $nstr = str_replace("\n", $this->LE, $nstr);
2864         }
2865         return $nstr;
2866     }
2867
2868     /**
2869      * Add a custom header.
2870      * $name value can be overloaded to contain
2871      * both header name and value (name:value)
2872      * @access public
2873      * @param string $name Custom header name
2874      * @param string $value Header value
2875      * @return void
2876      */
2877     public function addCustomHeader($name, $value = null)
2878     {
2879         if ($value === null) {
2880             // Value passed in as name:value
2881             $this->CustomHeader[] = explode(':', $name, 2);
2882         } else {
2883             $this->CustomHeader[] = array($name, $value);
2884         }
2885     }
2886
2887     /**
2888      * Create a message from an HTML string.
2889      * Automatically makes modifications for inline images and backgrounds
2890      * and creates a plain-text version by converting the HTML.
2891      * Overwrites any existing values in $this->Body and $this->AltBody
2892      * @access public
2893      * @param string $message HTML message string
2894      * @param string $basedir baseline directory for path
2895      * @param boolean|callable $advanced Whether to use the internal HTML to text converter
2896      * or your own custom converter @see html2text()
2897      * @return string $message
2898      */
2899     public function msgHTML($message, $basedir = '', $advanced = false)
2900     {
2901         preg_match_all('/(src|background)=["\'](.*)["\']/Ui', $message, $images);
2902         if (isset($images[2])) {
2903             foreach ($images[2] as $imgindex => $url) {
2904                 // Convert data URIs into embedded images
2905                 if (preg_match('#^data:(image[^;,]*)(;base64)?,#', $url, $match)) {
2906                     $data = substr($url, strpos($url, ','));
2907                     if ($match[2]) {
2908                         $data = base64_decode($data);
2909                     } else {
2910                         $data = rawurldecode($data);
2911                     }
2912                     $cid = md5($url) . '@phpmailer.0'; // RFC2392 S 2
2913                     if ($this->addStringEmbeddedImage($data, $cid, '', 'base64', $match[1])) {
2914                         $message = str_replace(
2915                             $images[0][$imgindex],
2916                             $images[1][$imgindex] . '="cid:' . $cid . '"',
2917                             $message
2918                         );
2919                     }
2920                 } elseif (!preg_match('#^[A-z]+://#', $url)) {
2921                     // Do not change urls for absolute images (thanks to corvuscorax)
2922                     $filename = basename($url);
2923                     $directory = dirname($url);
2924                     if ($directory == '.') {
2925                         $directory = '';
2926                     }
2927                     $cid = md5($url) . '@phpmailer.0'; // RFC2392 S 2
2928                     if (strlen($basedir) > 1 && substr($basedir, -1) != '/') {
2929                         $basedir .= '/';
2930                     }
2931                     if (strlen($directory) > 1 && substr($directory, -1) != '/') {
2932                         $directory .= '/';
2933                     }
2934                     if ($this->addEmbeddedImage(
2935                         $basedir . $directory . $filename,
2936                         $cid,
2937                         $filename,
2938                         'base64',
2939                         self::_mime_types((string)self::mb_pathinfo($filename, PATHINFO_EXTENSION))
2940                     )
2941                     ) {
2942                         $message = preg_replace(
2943                             '/' . $images[1][$imgindex] . '=["\']' . preg_quote($url, '/') . '["\']/Ui',
2944                             $images[1][$imgindex] . '="cid:' . $cid . '"',
2945                             $message
2946                         );
2947                     }
2948                 }
2949             }
2950         }
2951         $this->isHTML(true);
2952         // Convert all message body line breaks to CRLF, makes quoted-printable encoding work much better
2953         $this->Body = $this->normalizeBreaks($message);
2954         $this->AltBody = $this->normalizeBreaks($this->html2text($message, $advanced));
2955         if (empty($this->AltBody)) {
2956             $this->AltBody = 'To view this email message, open it in a program that understands HTML!' .
2957                 self::CRLF . self::CRLF;
2958         }
2959         return $this->Body;
2960     }
2961
2962     /**
2963      * Convert an HTML string into plain text.
2964      * This is used by msgHTML().
2965      * Note - older versions of this function used a bundled advanced converter
2966      * which was been removed for license reasons in #232
2967      * Example usage:
2968      * <code>
2969      * // Use default conversion
2970      * $plain = $mail->html2text($html);
2971      * // Use your own custom converter
2972      * $plain = $mail->html2text($html, function($html) {
2973      * $converter = new MyHtml2text($html);
2974      * return $converter->get_text();
2975      * });
2976      * </code>
2977      * @param string $html The HTML text to convert
2978      * @param boolean|callable $advanced Any boolean value to use the internal converter,
2979      * or provide your own callable for custom conversion.
2980      * @return string
2981      */
2982     public function html2text($html, $advanced = false)
2983     {
2984         if (is_callable($advanced)) {
2985             return call_user_func($advanced, $html);
2986         }
2987         return html_entity_decode(
2988             trim(strip_tags(preg_replace('/<(head|title|style|script)[^>]*>.*?<\/\\1>/si', '', $html))),
2989             ENT_QUOTES,
2990             $this->CharSet
2991         );
2992     }
2993
2994     /**
2995      * Get the MIME type for a file extension.
2996      * @param string $ext File extension
2997      * @access public
2998      * @return string MIME type of file.
2999      * @static
3000      */
3001     public static function _mime_types($ext = '')
3002     {
3003         $mimes = array(
3004             'xl' => 'application/excel',
3005             'js' => 'application/javascript',
3006             'hqx' => 'application/mac-binhex40',
3007             'cpt' => 'application/mac-compactpro',
3008             'bin' => 'application/macbinary',
3009             'doc' => 'application/msword',
3010             'word' => 'application/msword',
3011             'class' => 'application/octet-stream',
3012             'dll' => 'application/octet-stream',
3013             'dms' => 'application/octet-stream',
3014             'exe' => 'application/octet-stream',
3015             'lha' => 'application/octet-stream',
3016             'lzh' => 'application/octet-stream',
3017             'psd' => 'application/octet-stream',
3018             'sea' => 'application/octet-stream',
3019             'so' => 'application/octet-stream',
3020             'oda' => 'application/oda',
3021             'pdf' => 'application/pdf',
3022             'ai' => 'application/postscript',
3023             'eps' => 'application/postscript',
3024             'ps' => 'application/postscript',
3025             'smi' => 'application/smil',
3026             'smil' => 'application/smil',
3027             'mif' => 'application/vnd.mif',
3028             'xls' => 'application/vnd.ms-excel',
3029             'ppt' => 'application/vnd.ms-powerpoint',
3030             'wbxml' => 'application/vnd.wap.wbxml',
3031             'wmlc' => 'application/vnd.wap.wmlc',
3032             'dcr' => 'application/x-director',
3033             'dir' => 'application/x-director',
3034             'dxr' => 'application/x-director',
3035             'dvi' => 'application/x-dvi',
3036             'gtar' => 'application/x-gtar',
3037             'php3' => 'application/x-httpd-php',
3038             'php4' => 'application/x-httpd-php',
3039             'php' => 'application/x-httpd-php',
3040             'phtml' => 'application/x-httpd-php',
3041             'phps' => 'application/x-httpd-php-source',
3042             'swf' => 'application/x-shockwave-flash',
3043             'sit' => 'application/x-stuffit',
3044             'tar' => 'application/x-tar',
3045             'tgz' => 'application/x-tar',
3046             'xht' => 'application/xhtml+xml',
3047             'xhtml' => 'application/xhtml+xml',
3048             'zip' => 'application/zip',
3049             'mid' => 'audio/midi',
3050             'midi' => 'audio/midi',
3051             'mp2' => 'audio/mpeg',
3052             'mp3' => 'audio/mpeg',
3053             'mpga' => 'audio/mpeg',
3054             'aif' => 'audio/x-aiff',
3055             'aifc' => 'audio/x-aiff',
3056             'aiff' => 'audio/x-aiff',
3057             'ram' => 'audio/x-pn-realaudio',
3058             'rm' => 'audio/x-pn-realaudio',
3059             'rpm' => 'audio/x-pn-realaudio-plugin',
3060             'ra' => 'audio/x-realaudio',
3061             'wav' => 'audio/x-wav',
3062             'bmp' => 'image/bmp',
3063             'gif' => 'image/gif',
3064             'jpeg' => 'image/jpeg',
3065             'jpe' => 'image/jpeg',
3066             'jpg' => 'image/jpeg',
3067             'png' => 'image/png',
3068             'tiff' => 'image/tiff',
3069             'tif' => 'image/tiff',
3070             'eml' => 'message/rfc822',
3071             'css' => 'text/css',
3072             'html' => 'text/html',
3073             'htm' => 'text/html',
3074             'shtml' => 'text/html',
3075             'log' => 'text/plain',
3076             'text' => 'text/plain',
3077             'txt' => 'text/plain',
3078             'rtx' => 'text/richtext',
3079             'rtf' => 'text/rtf',
3080             'vcf' => 'text/vcard',
3081             'vcard' => 'text/vcard',
3082             'xml' => 'text/xml',
3083             'xsl' => 'text/xml',
3084             'mpeg' => 'video/mpeg',
3085             'mpe' => 'video/mpeg',
3086             'mpg' => 'video/mpeg',
3087             'mov' => 'video/quicktime',
3088             'qt' => 'video/quicktime',
3089             'rv' => 'video/vnd.rn-realvideo',
3090             'avi' => 'video/x-msvideo',
3091             'movie' => 'video/x-sgi-movie'
3092         );
3093         return (array_key_exists(strtolower($ext), $mimes) ? $mimes[strtolower($ext)]: 'application/octet-stream');
3094     }
3095
3096     /**
3097      * Map a file name to a MIME type.
3098      * Defaults to 'application/octet-stream', i.e.. arbitrary binary data.
3099      * @param string $filename A file name or full path, does not need to exist as a file
3100      * @return string
3101      * @static
3102      */
3103     public static function filenameToType($filename)
3104     {
3105         // In case the path is a URL, strip any query string before getting extension
3106         $qpos = strpos($filename, '?');
3107         if (false !== $qpos) {
3108             $filename = substr($filename, 0, $qpos);
3109         }
3110         $pathinfo = self::mb_pathinfo($filename);
3111         return self::_mime_types($pathinfo['extension']);
3112     }
3113
3114     /**
3115      * Multi-byte-safe pathinfo replacement.
3116      * Drop-in replacement for pathinfo(), but multibyte-safe, cross-platform-safe, old-version-safe.
3117      * Works similarly to the one in PHP >= 5.2.0
3118      * @link http://www.php.net/manual/en/function.pathinfo.php#107461
3119      * @param string $path A filename or path, does not need to exist as a file
3120      * @param integer|string $options Either a PATHINFO_* constant,
3121      * or a string name to return only the specified piece, allows 'filename' to work on PHP < 5.2
3122      * @return string|array
3123      * @static
3124      */
3125     public static function mb_pathinfo($path, $options = null)
3126     {
3127         $ret = array('dirname' => '', 'basename' => '', 'extension' => '', 'filename' => '');
3128         $pathinfo = array();
3129         if (preg_match('%^(.*?)[\\\\/]*(([^/\\\\]*?)(\.([^\.\\\\/]+?)|))[\\\\/\.]*$%im', $path, $pathinfo)) {
3130             if (array_key_exists(1, $pathinfo)) {
3131                 $ret['dirname'] = $pathinfo[1];
3132             }
3133             if (array_key_exists(2, $pathinfo)) {
3134                 $ret['basename'] = $pathinfo[2];
3135             }
3136             if (array_key_exists(5, $pathinfo)) {
3137                 $ret['extension'] = $pathinfo[5];
3138             }
3139             if (array_key_exists(3, $pathinfo)) {
3140                 $ret['filename'] = $pathinfo[3];
3141             }
3142         }
3143         switch ($options) {
3144             case PATHINFO_DIRNAME:
3145             case 'dirname':
3146                 return $ret['dirname'];
3147             case PATHINFO_BASENAME:
3148             case 'basename':
3149                 return $ret['basename'];
3150             case PATHINFO_EXTENSION:
3151             case 'extension':
3152                 return $ret['extension'];
3153             case PATHINFO_FILENAME:
3154             case 'filename':
3155                 return $ret['filename'];
3156             default:
3157                 return $ret;
3158         }
3159     }
3160
3161     /**
3162      * Set or reset instance properties.
3163      * You should avoid this function - it's more verbose, less efficient, more error-prone and
3164      * harder to debug than setting properties directly.
3165      * Usage Example:
3166      * `$mail->set('SMTPSecure', 'tls');`
3167      * is the same as:
3168      * `$mail->SMTPSecure = 'tls';`
3169      * @access public
3170      * @param string $name The property name to set
3171      * @param mixed $value The value to set the property to
3172      * @return boolean
3173      * @TODO Should this not be using the __set() magic function?
3174      */
3175     public function set($name, $value = '')
3176     {
3177         if (property_exists($this, $name)) {
3178             $this->$name = $value;
3179             return true;
3180         } else {
3181             $this->setError($this->lang('variable_set') . $name);
3182             return false;
3183         }
3184     }
3185
3186     /**
3187      * Strip newlines to prevent header injection.
3188      * @access public
3189      * @param string $str
3190      * @return string
3191      */
3192     public function secureHeader($str)
3193     {
3194         return trim(str_replace(array("\r", "\n"), '', $str));
3195     }
3196
3197     /**
3198      * Normalize line breaks in a string.
3199      * Converts UNIX LF, Mac CR and Windows CRLF line breaks into a single line break format.
3200      * Defaults to CRLF (for message bodies) and preserves consecutive breaks.
3201      * @param string $text
3202      * @param string $breaktype What kind of line break to use, defaults to CRLF
3203      * @return string
3204      * @access public
3205      * @static
3206      */
3207     public static function normalizeBreaks($text, $breaktype = "\r\n")
3208     {
3209         return preg_replace('/(\r\n|\r|\n)/ms', $breaktype, $text);
3210     }
3211
3212
3213     /**
3214      * Set the public and private key files and password for S/MIME signing.
3215      * @access public
3216      * @param string $cert_filename
3217      * @param string $key_filename
3218      * @param string $key_pass Password for private key
3219      */
3220     public function sign($cert_filename, $key_filename, $key_pass)
3221     {
3222         $this->sign_cert_file = $cert_filename;
3223         $this->sign_key_file = $key_filename;
3224         $this->sign_key_pass = $key_pass;
3225     }
3226
3227     /**
3228      * Quoted-Printable-encode a DKIM header.
3229      * @access public
3230      * @param string $txt
3231      * @return string
3232      */
3233     public function DKIM_QP($txt)
3234     {
3235         $line = '';
3236         for ($i = 0; $i < strlen($txt); $i++) {
3237             $ord = ord($txt[$i]);
3238             if (((0x21 <= $ord) && ($ord <= 0x3A)) || $ord == 0x3C || ((0x3E <= $ord) && ($ord <= 0x7E))) {
3239                 $line .= $txt[$i];
3240             } else {
3241                 $line .= '=' . sprintf('%02X', $ord);
3242             }
3243         }
3244         return $line;
3245     }
3246
3247     /**
3248      * Generate a DKIM signature.
3249      * @access public
3250      * @param string $signHeader
3251      * @throws phpmailerException
3252      * @return string
3253      */
3254     public function DKIM_Sign($signHeader)
3255     {
3256         if (!defined('PKCS7_TEXT')) {
3257             if ($this->exceptions) {
3258                 throw new phpmailerException($this->lang('signing') . ' OpenSSL extension missing.');
3259             }
3260             return '';
3261         }
3262         $privKeyStr = file_get_contents($this->DKIM_private);
3263         if ($this->DKIM_passphrase != '') {
3264             $privKey = openssl_pkey_get_private($privKeyStr, $this->DKIM_passphrase);
3265         } else {
3266             $privKey = $privKeyStr;
3267         }
3268         if (openssl_sign($signHeader, $signature, $privKey)) {
3269             return base64_encode($signature);
3270         }
3271         return '';
3272     }
3273
3274     /**
3275      * Generate a DKIM canonicalization header.
3276      * @access public
3277      * @param string $signHeader Header
3278      * @return string
3279      */
3280     public function DKIM_HeaderC($signHeader)
3281     {
3282         $signHeader = preg_replace('/\r\n\s+/', ' ', $signHeader);
3283         $lines = explode("\r\n", $signHeader);
3284         foreach ($lines as $key => $line) {
3285             list($heading, $value) = explode(':', $line, 2);
3286             $heading = strtolower($heading);
3287             $value = preg_replace('/\s+/', ' ', $value); // Compress useless spaces
3288             $lines[$key] = $heading . ':' . trim($value); // Don't forget to remove WSP around the value
3289         }
3290         $signHeader = implode("\r\n", $lines);
3291         return $signHeader;
3292     }
3293
3294     /**
3295      * Generate a DKIM canonicalization body.
3296      * @access public
3297      * @param string $body Message Body
3298      * @return string
3299      */
3300     public function DKIM_BodyC($body)
3301     {
3302         if ($body == '') {
3303             return "\r\n";
3304         }
3305         // stabilize line endings
3306         $body = str_replace("\r\n", "\n", $body);
3307         $body = str_replace("\n", "\r\n", $body);
3308         // END stabilize line endings
3309         while (substr($body, strlen($body) - 4, 4) == "\r\n\r\n") {
3310             $body = substr($body, 0, strlen($body) - 2);
3311         }
3312         return $body;
3313     }
3314
3315     /**
3316      * Create the DKIM header and body in a new message header.
3317      * @access public
3318      * @param string $headers_line Header lines
3319      * @param string $subject Subject
3320      * @param string $body Body
3321      * @return string
3322      */
3323     public function DKIM_Add($headers_line, $subject, $body)
3324     {
3325         $DKIMsignatureType = 'rsa-sha1'; // Signature & hash algorithms
3326         $DKIMcanonicalization = 'relaxed/simple'; // Canonicalization of header/body
3327         $DKIMquery = 'dns/txt'; // Query method
3328         $DKIMtime = time(); // Signature Timestamp = seconds since 00:00:00 - Jan 1, 1970 (UTC time zone)
3329         $subject_header = "Subject: $subject";
3330         $headers = explode($this->LE, $headers_line);
3331         $from_header = '';
3332         $to_header = '';
3333         $current = '';
3334         foreach ($headers as $header) {
3335             if (strpos($header, 'From:') === 0) {
3336                 $from_header = $header;
3337                 $current = 'from_header';
3338             } elseif (strpos($header, 'To:') === 0) {
3339                 $to_header = $header;
3340                 $current = 'to_header';
3341             } else {
3342                 if ($current && strpos($header, ' =?') === 0) {
3343                     $current .= $header;
3344                 } else {
3345                     $current = '';
3346                 }
3347             }
3348         }
3349         $from = str_replace('|', '=7C', $this->DKIM_QP($from_header));
3350         $to = str_replace('|', '=7C', $this->DKIM_QP($to_header));
3351         $subject = str_replace(
3352             '|',
3353             '=7C',
3354             $this->DKIM_QP($subject_header)
3355         ); // Copied header fields (dkim-quoted-printable)
3356         $body = $this->DKIM_BodyC($body);
3357         $DKIMlen = strlen($body); // Length of body
3358         $DKIMb64 = base64_encode(pack('H*', sha1($body))); // Base64 of packed binary SHA-1 hash of body
3359         $ident = ($this->DKIM_identity == '') ? '' : ' i=' . $this->DKIM_identity . ';';
3360         $dkimhdrs = 'DKIM-Signature: v=1; a=' .
3361             $DKIMsignatureType . '; q=' .
3362             $DKIMquery . '; l=' .
3363             $DKIMlen . '; s=' .
3364             $this->DKIM_selector .
3365             ";\r\n" .
3366             "\tt=" . $DKIMtime . '; c=' . $DKIMcanonicalization . ";\r\n" .
3367             "\th=From:To:Subject;\r\n" .
3368             "\td=" . $this->DKIM_domain . ';' . $ident . "\r\n" .
3369             "\tz=$from\r\n" .
3370             "\t|$to\r\n" .
3371             "\t|$subject;\r\n" .
3372             "\tbh=" . $DKIMb64 . ";\r\n" .
3373             "\tb=";
3374         $toSign = $this->DKIM_HeaderC(
3375             $from_header . "\r\n" . $to_header . "\r\n" . $subject_header . "\r\n" . $dkimhdrs
3376         );
3377         $signed = $this->DKIM_Sign($toSign);
3378         return $dkimhdrs . $signed . "\r\n";
3379     }
3380
3381     /**
3382      * Allows for public read access to 'to' property.
3383      * @access public
3384      * @return array
3385      */
3386     public function getToAddresses()
3387     {
3388         return $this->to;
3389     }
3390
3391     /**
3392      * Allows for public read access to 'cc' property.
3393      * @access public
3394      * @return array
3395      */
3396     public function getCcAddresses()
3397     {
3398         return $this->cc;
3399     }
3400
3401     /**
3402      * Allows for public read access to 'bcc' property.
3403      * @access public
3404      * @return array
3405      */
3406     public function getBccAddresses()
3407     {
3408         return $this->bcc;
3409     }
3410
3411     /**
3412      * Allows for public read access to 'ReplyTo' property.
3413      * @access public
3414      * @return array
3415      */
3416     public function getReplyToAddresses()
3417     {
3418         return $this->ReplyTo;
3419     }
3420
3421     /**
3422      * Allows for public read access to 'all_recipients' property.
3423      * @access public
3424      * @return array
3425      */
3426     public function getAllRecipientAddresses()
3427     {
3428         return $this->all_recipients;
3429     }
3430
3431     /**
3432      * Perform a callback.
3433      * @param boolean $isSent
3434      * @param array $to
3435      * @param array $cc
3436      * @param array $bcc
3437      * @param string $subject
3438      * @param string $body
3439      * @param string $from
3440      */
3441     protected function doCallback($isSent, $to, $cc, $bcc, $subject, $body, $from)
3442     {
3443         if (!empty($this->action_function) && is_callable($this->action_function)) {
3444             $params = array($isSent, $to, $cc, $bcc, $subject, $body, $from);
3445             call_user_func_array($this->action_function, $params);
3446         }
3447     }
3448 }
3449
3450 /**
3451  * PHPMailer exception handler
3452  * @package PHPMailer
3453  */
3454 class phpmailerException extends Exception
3455 {
3456     /**
3457      * Prettify error message output
3458      * @return string
3459      */
3460     public function errorMessage()
3461     {
3462         $errorMsg = '<strong>' . $this->getMessage() . "</strong><br />\n";
3463         return $errorMsg;
3464     }
3465 }



Full source code website bán hàng thương mại điện tử gần giống shopee 467.443 lượt xem

Gõ tìm kiếm nhanh...



Dự án liên quan!

fullstack web blogger tin tức

400,000
Source code Website bán hàng online PHP – MVC

Source code Website bán hàng online PHP – MVC

65,000
Full source code Hệ thống cho thuê xe ngôn ngữ ANDROID

Full source code Hệ thống cho thuê xe ngôn ngữ ANDROID

29.354 lượt xem
Full source project EverWing trong Unity Engine

Full source project EverWing trong Unity Engine

20.332 lượt xem
Full source game đan lan hoa bánh xe điêu luyện

Full source game đan lan hoa bánh xe điêu luyện

14.052 lượt xem
Full source code ứng dụng hướng dẫn du lịch thiết bị android

Full source code ứng dụng hướng dẫn du lịch thiết bị android

19.471 lượt xem